C# の基礎中の基礎 - クラスライブラリ

 [Home] |  [Index] | 投稿日 2015/06/02


 

もくじ


 

 コンソール


詳細は 参照。


文字列出力について

文字列出力については、以下のようなメソッドがある。

文字列出力に関連するプロパティについては、以下のようなものがある。

サンプル

using System;

public class ConsoleTest
{
  public static void Main()
  {
     // 現在の色を取得
     var fgColor = Console.ForegroundColor;
     var bgColor = Console.BackgroundColor;
     // 現在の色を表示
     Console.WriteLine(fgColor);
     Console.WriteLine(bgColor);
     // 前景色を変更して表示
     Console.ForegroundColor = ConsoleColor.Cyan;
     Console.WriteLine("ConsoleTest");
     
     // 色を元に戻す。※ これがないとプログラム終了後も色が変わったままになる。
     Console.ResetColor();
  }
}

キー入力について

キー入力については、以下のようなメソッドがある。

キー入力に関連するプロパティについては、以下のようなものがある。

サンプル

using System;

public class ReadKeyTest
{
  public static void Main()
  {
     // 文字列を読む。
     Console.Write("str> ");
     var s = Console.ReadLine();
     Console.WriteLine(s.ToUpper());
     
     // 文字を読む。
     Console.Write("char> ");
     var i = Console.Read();
     Console.WriteLine((char)i);
     
     // キーを読む。
     Console.Write("key> ");
     var keyinfo = Console.ReadKey();  // ConsoleKeyInfo 型が返る。
     Console.WriteLine("\n{0:x}", keyinfo.Key);
     Console.WriteLine(keyinfo.KeyChar);
     
     // エコーしないでキーを読む。
     Console.Write("key> ");
     keyinfo = Console.ReadKey(true);  // ConsoleKeyInfo 型が返る。
     Console.WriteLine("\n{0:x}", keyinfo.Key);
     Console.WriteLine(keyinfo.KeyChar);
  }
}

実行例

str> abc
ABC
char> e
e
key> 1
00000031
1
key>
00000032
2

標準ストリームについて

標準ストリームについては、以下のようなメソッドがある。

標準ストリームに関連するプロパティについては、以下のようなものがある。

OpenStandardError() のサンプル

using System;
using System.IO;

public class StdStreamTest
{
  public static void Main()
  {
     byte[] buffer = { 0x31, 0x41, 0x42 };
     var stream = Console.OpenStandardError();
     foreach (byte b in buffer)
     {
       stream.WriteByte(b);
     }
     stream.Flush();
  }
}

Console.In のサンプル

using System;
using System.IO;

public class StdInTest
{
  public static void Main()
  {
     var tIn = Console.In;  // TextReader オブジェクト
     Console.WriteLine("> ");
     var s = tIn.ReadLine();
     Console.WriteLine(s);
  }
}

カーソルについて

カーソルについては、以下のようなメソッドがある。

カーソルに関連するプロパティについては、以下のようなものがある。

CursorTop, CursurLeft のサンプル

using System;

public class CursorTest
{
  public static void Main()
  {
     Console.WriteLine("カーソルの位置 (x, y)");
     Console.WriteLine(Console.CursorLeft);
     Console.WriteLine(Console.CursorTop);
     Console.WriteLine("カーソルの位置 (20, 10)");
     Console.CursorLeft = 20;
     Console.CursorTop = 10;
  }
}

ウィンドウについて

ウィンドウについては、以下のようなメソッドがある。

ウィンドウに関連するプロパティについては、以下のようなものがある。

サンプル

using System;

public class WindowTest
{
  public static void Main()
  {
     Console.WriteLine("タイトル " + Console.Title);
     Console.WriteLine("コンソールウィンドウの幅と高さ");
     Console.WriteLine(Console.WindowWidth);
     Console.WriteLine(Console.WindowHeight);
     
     Console.Title = "Test";  // 実際には変更できないようです。
     Console.WriteLine(Console.Title);
  }
}

その他

その他の項目については、以下のようなメソッドがある。

その他の項目のプロパティについては、以下のようなものがある。

[Top] [SubIndex]

 

 コレクション


System.Collection.Generic の詳細は MSDN 参照。


Dictionary<TKey, TValue>

Dictionary<TKey, TValue> は連想配列を表すクラスである。

using System;
using System.Collections.Generic;

public class DictionaryTest
{
  public static void Main()
  {
     var dic = new Dictionary<string, string>() {
        {"TYO", "Tokyo"},
        {"NYC", "New York"},
        {"LAX", "Los Angeles"},
        {"SFO", "San Francisco"}
     };
     
     dic["FUK"] = "Fukuoka";
     dic.Add("OKA", "Okinawa");
     
     foreach (var key in dic.Keys)
     {
        Console.WriteLine("{0}:{1}", key, dic[key]);
     }
  }
}

[Top] [SubIndex]


HashSet<T>

HashSet<T> は T の集合を表す。したがって、すでに含まれている要素を追加してもダブった要素にはならない。

using System;
using System.Collections.Generic;

public class HashSetTest
{
  public static void Main()
  {
     var hs = new HashSet<string>()
     {
        "Bangkok", "Manila", "Hanoi", "Kuala Lumpur"
     };
     
     Console.WriteLine(hs.Contains("Manila"));  // True
     Console.WriteLine(hs.Contains("Singapore"));  // False
     
     hs.Add("Bangkok");  // すでに含まれている場合は、二重にはならない。
     
     foreach (var x in hs)
     {
        Console.WriteLine(x);
     }
  }
}

実行例

True
False
Bangkok
Manila
Hanoi
Kuala Lumpur

[Top] [SubIndex]


LinkedList<T>

LinkedList<T> は T の双方向リストを表す。List<T> と異なりインデクサを使ってのアクセスはできない。

using System;
using System.Collections.Generic;

public class LinkedListTest
{
  public static void Main()
  {
     var llist = new LinkedList<string>();
     string[] cities =  {
        "Bangkok", "Manila", "Hanoi", "Kuala Lumpur", "Singapore"
     };
     
     // リストの最後に追加
     foreach (var x in cities)
     {
        llist.AddLast(x);
     }
     
     // リストの内容を確認
     foreach (var x in llist)
     {
        Console.WriteLine(x);
     }
     
     var node = llist.Find("Hanoi");  // 最初のノードを見つける。
     Console.WriteLine(node.Value);
     node = node.Next;  // 次のノードへ
     Console.WriteLine(node.Value);
  }
}

実行例

Bangkok
Manila
Hanoi
Kuala Lumpur
Singapore
Hanoi
Kuala Lumpur

[Top] [SubIndex]


List<T>

List<T> は LinkedList より高機能でインデクサを持つ。

using System;
using System.Collections.Generic;

public class ListTest1
{
  public static void Main()
  {
     var list = new List<string>() {
        "Bangkok", "Manila", "Hanoi", "Kuala Lumpur", "Singapore"
     };
     
     list.Add("Yangon");
     list.Add("Jakarta");
     
     int n = list.Count;
     Console.WriteLine(n);
     for (int i = 0; i < n; i++)
     {
        Console.WriteLine(list[i]);  // LinkedList はインデクサが使えないため、こういう書き方はできない。
     }
  }
}

実行例

7
Bangkok
Manila
Hanoi
Kuala Lumpur
Singapore
Yangon
Jakarta

Linq を使って操作もできる。(List<T>に限ったことではない)

using System;
using System.Collections.Generic;
using System.Linq;

public class ListTest2
{
  class City
  {
     public string Name { get; set; }
     public string Country { get; set; }
  }
  
  public static void Main()
  {
     var cities = new List<City>() {
        new City() { Name = "Bangkok", Country = "Thailand" },
        new City() { Name = "Manila", Country = "Philippines" },
        new City() { Name = "Hanoi", Country = "Vietnam" },
        new City() { Name = "Kuala Lumpur", Country = "Malaysia" },
        new City() { Name = "Ho Chi Minh", Country = "Vietnam" },
        new City() { Name = "Chiang Mai", Country = "Thailand" },
        new City() { Name = "Pattaya", Country = "Thailand" },
        new City() { Name = "Cebu City", Country = "Philippines" }
     };
     
     // コレクションの最初の都市を表示
     var y = cities.First<City>();
     Console.WriteLine("{0} {1}", y.Name, y.Country);
     Console.WriteLine();
     
     // 国名で並べ替えて表示
     IEnumerable<City> q = cities.OrderBy((x) => x.Country);
     foreach (var x in q)
     {
        Console.WriteLine("{0}, {1}", x.Country, x.Name);
     }
  }
}

実行例

Bangkok Thailand

Malaysia, Kuala Lumpur
Philippines, Manila
Philippines, Cebu City
Thailand, Bangkok
Thailand, Chiang Mai
Thailand, Pattaya
Vietnam, Hanoi
Vietnam, Ho Chi Minh

[Top] [SubIndex]


Queue<T>

Queue<T> は待ち行列を表す。(先入れ先出し)

using System;
using System.Collections.Generic;

public class QueueTest
{
  public static void Main()
  {
     var queue = new Queue<int>();
     
     queue.Enqueue(33);
     queue.Enqueue(31);
     queue.Enqueue(32);
     queue.Enqueue(35);
     queue.Enqueue(39);
     
     while (queue.Count > 0)
     {
        var i = queue.Dequeue();
        Console.WriteLine(i);   // 要素が Enqueue メソッドで追加した順番で表示される。
     }
  }
}

[Top] [SubIndex]


SortedDictionary<TKey, TValue>

SortedDictionary<TKey, TValue> は キーの順番で要素が並び替えられて保持される。一方、Dictionary<TKey, TValue> はキーの順番とは関係なく要素を保持する。

using System;
using System.Collections.Generic;
using System.Linq;

public class SortedDictionaryTest
{
  public static void Main()
  {
     var dic = new SortedDictionary<string, string>() {
        {"TYO", "Tokyo"},
        {"NYC", "New York"},
        {"LAX", "Los Angeles"},
        {"SFO", "San Francisco"}
     };
     
     dic["FUK"] = "Fukuoka";
     dic.Add("OKA", "Okinawa");
     
     foreach (var key in dic.Keys)
     {
        Console.WriteLine("{0}:{1}", key, dic[key]);  // キーの順番で表示される。
     }
     
     // 逆順にする場合
     IEnumerable<string> q = dic.Keys.Reverse();
     foreach (var key in q)
     {
        Console.WriteLine("{0}:{1}", key, dic[key]);
     }
  }
}

実行例

FUK:Fukuoka
LAX:Los Angeles
NYC:New York
OKA:Okinawa
SFO:San Francisco
TYO:Tokyo
TYO:Tokyo
SFO:San Francisco
OKA:Okinawa
NYC:New York
LAX:Los Angeles
FUK:Fukuoka  p

[Top] [SubIndex]


SortedList<TKey, TValue>

SortedList<TKey, TValue> はキーを並べ替えるための IComparer<T> を実装した比較オブジェクトを指定できる。

using System;
using System.Collections.Generic;
using System.Linq;

public class SortedListTest
{
  // IComparer<T> を実装したクラスでソート順を定義する。
  class Comparer1 : IComparer<string>
  {
     public int Compare(string x, string y)
     {
        return x.Length - y.Length;
     }
  }
  
  public static void Main()
  {
     var cmp = new Comparer1();
     var dic = new SortedList<string, string>(cmp) {
        {"Tokyo", "TYO"},
        {"New York", "NYC"},
        {"Los Angeles", "LAX"},
        {"San Francisco", "SFO"}
     };
     
     foreach (var key in dic.Keys)
     {
        Console.WriteLine("{0}:{1}", key, dic[key]);  // キーの長さの順番で表示される。
     }
  }
}

実行例

Tokyo:TYO
New York:NYC
Los Angeles:LAX
San Francisco:SFO

[Top] [SubIndex]


SortedSet<T>

HashSet<T> では要素の順番は不定であるが、SortedSet<T> ではソートされる。

using System;
using System.Collections.Generic;
using System.Linq;

public class SortedSetTest
{
  public static void Main()
  {
     var set1 = new SortedSet<string>();
     set1.Add("London");
     set1.Add("Paris");
     set1.Add("Rome");
     set1.Add("Madrid");
     set1.Add("London");  // Set (集合) なので追加されない(エラーにはならない)
     
     foreach (var x in set1)
     {
        Console.WriteLine(x);
     }
  }
}

実行例

London
Madrid
Paris
Rome

[Top] [SubIndex]


Stack<T>

Stack<T> はスタックを表す。

using System;
using System.Collections.Generic;

public class StackTest
{
  public static void Main()
  {
     var stack1 = new Stack<string>();
     stack1.Push("London");
     stack1.Push("Paris");
     stack1.Push("Rome");
     stack1.Push("Madrid");
     
     int n = stack1.Count;
     for (int i = 0; i < n; i++)
     {
        var s = stack1.Pop();
        Console.WriteLine(s);
     }
  }
}

実行例

Madrid
Rome
Paris
London

[Top] [SubIndex]


 

 文字列 & 書式

書式と Format メソッドの使い方

書式の例

using System;

public class FormatTest
{
  public static void Main()
  {
     string s;
     
     // 整数の書式
     s = String.Format("{0:d10}", 123);  // 10桁で0埋め
     Console.WriteLine(s);
     s = String.Format("{0:00000}", 123);  // 5桁で0埋め
     Console.WriteLine(s);
     s = String.Format("{0,10:d}", 123); // 10桁で空白埋め
     Console.WriteLine(s);
     s = String.Format("{0:######}", 123); // 左詰め
     Console.WriteLine(s);
     s = String.Format("{0:0#####}", 123); // 左詰め0埋め
     Console.WriteLine(s);
     
     // 固定小数点数の書式
     s = String.Format("{0:f5} {1:f2}", 123.456, 78.9);  // 小数点以下5桁と2桁
     Console.WriteLine(s);
     s = String.Format("{0, 15:f5}", 123.456);  // 全体で15桁、小数点以下5桁
     Console.WriteLine(s);
     
     // 浮動小数点の書式
     s = String.Format("{0:e5}", 1.234e2);   // 小数点以下5桁
     Console.WriteLine(s);
     s = String.Format("{0, 30:e5}", 1.234e2);  // 全体で30桁、小数点以下5桁
     Console.WriteLine(s);
     
     // 16進数の書式
     s = String.Format("{0:x6}", 0xfedc);   // 6桁で0埋め小文字
     Console.WriteLine(s);
     s = String.Format("{0:X6}", 0xfedc);   // 6桁で0埋め大文字
     Console.WriteLine(s);
     
     // 金額の書式
     s = String.Format("{0:c}", 1000000000);  // 3桁ごとにカンマが入り¥が先頭に付く。
     Console.WriteLine(s);
     
     // 日付と時刻の書式
     s = String.Format("{0:d}", DateTime.Now);  // 2015/06/04
     Console.WriteLine(s);
     s = String.Format("{0:g}", DateTime.Now);  // 2015/06/04 12:00
     Console.WriteLine(s);
     s = String.Format("{0:F}", DateTime.Now);  // 2015年6月4日 12:00:00
     Console.WriteLine(s);
     s = String.Format("{0:T}", DateTime.Now);  // 12:00:00
     Console.WriteLine(s);
     s = String.Format("{0:t}", DateTime.Now);  // 12:00
     Console.WriteLine(s);
     s = String.Format("{0:yyyy-mm-dd hh:MM:ss}", DateTime.Now);  // 2015/06/04 12:00:00   
     Console.WriteLine(s);
     
     // パーセント
     s = String.Format("{0:p}", 0.23);  // 100倍した値に%が最後に付く。
     Console.WriteLine(s);
  }
}

実行例

0000000123
00123
       123
123
000123
123.45600 78.90
      123.45600
1.23400e+002
                  1.23400e+002
00fedc
00FEDC
\1,000,000,000
2015/06/04
2015/06/04 12:12
2015年6月4日 12:12:44
12:12:44
12:12
2015-12-04 12:06:44
23.00%

[Top] [SubIndex]


文字列の複製を作るには

文字列の複製を作るには Copy または CopyTo メソッドを使う。 ※ Clone メソッドはその文字列の参照を返すだけなので注意。

using System;

public class CopyTest
{
  public static void Main()
  {
     string s1 = "ABCD";
     string s2 = String.Copy(s1);  // 値が同じの新しいインスタンスを作る。
     Console.WriteLine(s2);
     Console.WriteLine((object)s1 == (object)s2);  // インスタンスが違うので False
     Console.WriteLine(s1.Equals(s2));  // 値が同じなので True
     
     // CopyTo は部分文字列を文字の配列にコピーする。
     char[] buff = new char[2];
     s1.CopyTo(1, buff, 0, 2);
     for (int i = 0; i < buff.Length; i++)
       Console.WriteLine(buff[i]);
  }
}

[Top] [SubIndex]


Equals メソッドと == の違い

Eqauls メソッドは値が等しいかどうかを返す。== 演算子は値型オブジェクトなら Equals と同じだが、参照型だとインスタンスが同じかを返す。

文字列の場合は、参照型だが例外で== 演算子は値の等価を返す。(==演算子がオーバーライドされている)

つまり、文字列に関しては == と Equals は同じ結果を返す。

[Top] [SubIndex]


Compare メソッドの使い方

Compare メソッドは文字列の大小 (1, 0, -1) を返す。CurltureInfo を指定するとアルファベット以外の言語も比較可能である。

using System;
using System.Globalization;

public class CompareTest
{
  public static void Main()
  {
     var ci = new CultureInfo("ja-jp");
     Console.WriteLine(String.Compare("東京", "大阪", false, ci));  // 1
     Console.WriteLine(String.Compare("福岡", "大阪", false, ci));  // 1
     Console.WriteLine(String.Compare("広島", "大阪", false, ci));  // -1
     Console.WriteLine(String.Compare("名古屋", "大阪", false, ci));  // 1
     Console.WriteLine(String.Compare("大阪", "大阪", false, ci));  // 0
  }
}

[Top] [SubIndex]


文字列を分割・結合するには

文字列を分割するには Split、結合するには Join メソッドを使う。

using System;

public class JoinTest
{
  public static void Main()
  {
    var strarr = new string[] { "AB", "c", "DEF", "ghi" };
    var str = String.Join("-", strarr);  // 結合
    Console.WriteLine(str);
    var strarr1 = str.Split('-');  // 分割
    for (int i = 0; i < strarr1.Length; i++)
      Console.WriteLine(strarr1[i]);
  }
}

[Top] [SubIndex]


部分文字列を検索するには

using System;

public class IndexOfTest
{
  public static void Main()
  {
     var str = "指定された文字列がこのインスタンス内で最初に見つかった位置の 0 から始まるインデックスを返す。";
     Console.WriteLine(str.IndexOf("文字列"));  // 5
     Console.WriteLine(str.IndexOf("最初", 0, 10));  // 見つからないため -1
  }
}

※ 単に部分文字列が含まれているかだけをブール値として得るには Contains メソッドを使用する。

[Top] [SubIndex]


部分文字列を得るには

using System;

public class SubStrTest
{
  public static void Main()
  {
     var str = "インスタンスから部分文字列を取得します。";
     Console.WriteLine(str.Substring(8));  // 部分文字列を取得します。
     Console.WriteLine(str.Substring(0, 6));  // インスタンス
     Console.WriteLine(str.Substring(str.Length - 6, 6));  // 取得します。
  }
}

[Top] [SubIndex]


部分文字列を置換には

using System;

public class ReplaceTest
{
  public static void Main()
  {
     var str = "現在のインスタンスに出現する指定した文字列をすべて、別に指定した文字列に置換した新しい文字列を返します。";
     Console.WriteLine(str.Replace("文字列", " String "));
  }
}

[Top] [SubIndex]


トリミングするには

using System;

public class TrimTest
{
  public static void Main()
  {
    var str = "\t\tTrim String.////";
    Console.WriteLine(str.Trim());
    Console.WriteLine(str.Trim(new char[] { '/' }));
    Console.WriteLine(str.TrimStart(new char[] { ' ', '\t', '/' }));
    Console.WriteLine(str.TrimEnd(new char[] { ' ', '\t', '/' }));
  }
}

実行例

Trim String.////
                Trim String.
Trim String.////
                Trim String.

[Top] [SubIndex]


パディングするには

using System;

public class PadTest
{
  public static void Main()
  {
    var str = "Pad String.";
    Console.WriteLine(str.PadLeft(12));  // 第一引数は全体の文字列長
    Console.WriteLine(str.PadLeft(12, '*'));  // 第一引数は全体の文字列長
    Console.WriteLine(str.PadRight(12, '*'));
  }
}

実行例

Pad String.
*Pad String.
Pad String.*

[Top] [SubIndex]


文字配列から変換するには

using System;

public class StringCtorTest
{
  public static void Main()
  {
     char[] chars = new char[] { 'a', 'b', 'c', 'd' };
     string str = new String(chars);
     Console.WriteLine(str);
  }
}

[Top] [SubIndex]


空白か判別するには

using System;

public class IsNullTest
{
  public static void Main()
  {
     Console.WriteLine(String.IsNullOrEmpty("AAA"));  // False
     Console.WriteLine(String.IsNullOrEmpty(""));  // True
     Console.WriteLine(String.IsNullOrEmpty(" \t "));  // False
     Console.WriteLine(String.IsNullOrEmpty(null));  //True
     Console.WriteLine(String.IsNullOrWhiteSpace("AAA"));  // False
     Console.WriteLine(String.IsNullOrWhiteSpace(""));  // True
     Console.WriteLine(String.IsNullOrWhiteSpace(" \t "));  // True
     Console.WriteLine(String.IsNullOrWhiteSpace(null));  // True
  }
}

[Top] [SubIndex]


開始または終了文字列を判別するには

using System;

public class StartWithTest
{
  public static void Main()
  {
    var str = "\t\twhile (i > 0) {";
    Console.WriteLine(str.StartsWith("\t"));  // True
    Console.WriteLine(str.StartsWith(" "));  // False
    Console.WriteLine(str.EndsWith("{"));  // True
    Console.WriteLine(str.EndsWith("\n"));  // False
  }
}

[Top] [SubIndex]


配列を結合して1つの文字列にするには

using System;

public class ConcatTest
{
  public static void Main()
  {
     string[] strs = new string[] { "A", "Bc", "De", "FGH" };
     Console.WriteLine(String.Concat(strs));
  }
}

[Top] [SubIndex]

 

 エンコーディング


UTF8 でエンコードされたファイルの表示

using System;
using System.Text;
using System.IO;

public class Program
{
  public static void Main()
  {
    // UTF8 でエンコードされたファイルを読んで表示する。
    using(StreamReader stream = new StreamReader("UTF8_TEXT.TXT", Encoding.UTF8))
    {
      string s;
      
      while ((s = stream.ReadLine()) != null)
      {
        Console.WriteLine(s);
      }
      
      stream.Close();
    }
  }
}

[Top] [SubIndex]


Shift JIS でエンコードされたファイルの読み込み

using System;
using System.Text;
using System.IO;

public class Program
{
  public static void Main()
  {
    // Shift JIS でエンコードされたファイルの読み込み。
    //   Windows の場合は、Encoding.GetEncoding("Shift_JIS") の代わりに Encoding.Default としてもよい。
    using(StreamReader stream = new StreamReader("S_JIS_TEXT.TXT", Encoding.GetEncoding("Shift_JIS")))
    {
      string s;
      
      while ((s = stream.ReadLine()) != null)
      {
        Console.WriteLine(s);
      }
      
      stream.Close();
    }
  }
}

[Top] [SubIndex]


EUC-JP でエンコードされたファイルの読み込み

using System;
using System.Text;
using System.IO;

public class Program
{
  public static void Main()
  {
    // EUC-JP でエンコードされたファイルの読み込み。
    using(StreamReader stream = new StreamReader("EUC_TEXT.TXT", Encoding.GetEncoding("EUC-JP")))
    {
      string s;
      
      while ((s = stream.ReadLine()) != null)
      {
        Console.WriteLine(s);
      }
      
      stream.Close();
    }
  }
}

[Top] [SubIndex]


Unicode 文字列のバイト列への変換と UTF8 への変換

using System;
using System.Text;
using System.IO;

public class Program
{
  public static void Main()
  {
    string data = "あかさたな";
    
    // バイト配列への変換
    UnicodeEncoding enc = new UnicodeEncoding();
    byte[] buffer = enc.GetBytes(data);  // Unicode文字列をバイト配列に変換
    foreach (byte b in buffer)
    {
      Console.Write("{0,2:x} ", b);
    }
    Console.WriteLine();
    
    // エンコードの変更(Unicode-->UTF8)
    byte[] buffer2 = Encoding.Convert(Encoding.Unicode, Encoding.UTF8, buffer);
    foreach (byte b in buffer2)
    {
      Console.Write("{0,2:x} ", b);
    }
    Console.WriteLine();
    using (BinaryWriter writer = new BinaryWriter(new FileStream("Convert.txt", FileMode.OpenOrCreate)))
    {
      writer.Write(buffer2, 0, buffer2.Length);
      writer.Close();
    }
  }
}

[Top] [SubIndex]


バイナリーファイルとして読み込んだデータを UTF8 として表示

using System;
using System.Text;
using System.IO;

public class Program
{
  public static void Main()
  {
    // バイナリーファイルとして読み込んだデータを UTF8 として表示する
    using(BinaryReader reader = new BinaryReader(new FileStream("UTF8_TEXT.TXT", FileMode.Open)))
    {
      byte[] buffer = new byte[1024];
      int n = reader.Read(buffer, 0, buffer.Length);
      Console.WriteLine("読み込んだバイト数=" + n);
      UTF8Encoding utf8 = new UTF8Encoding();
      string s = utf8.GetString(buffer, 0, n);
      Console.WriteLine(s);
      reader.Close();
    }
  }
}

[Top] [SubIndex]

 

 正規表現


一致のチェック (IsMatch())

using System;
using System.Text;
using System.Text.RegularExpressions;

public class IsMatch
{
  public static void Main()
  {
    var str = "127.0.0.1 - - [03/Mar/2014:08:21:37 +0900] \"GET /index.php HTTP/1.1\" 200 8095";
    var re = new Regex(@"\d+\.\d+\.\d\.\d");
    // パターンに一致するものがあれば True、なければ False を表示する。
    Console.WriteLine(re.IsMatch(str));  // True
    str = "127.00.1 - - [03/Mar/2014:08:21:37 +0900] \"GET /index.php HTTP/1.1\" 200 8095";
    re = new Regex(@"\d+\.\d+\.\d\.\d");
    Console.WriteLine(re.IsMatch(str));  // False
    // スタティックなメソッドもある。
    var b = Regex.IsMatch(str, @"\d+\.\d+\.\d\.\d");
    Console.WriteLine(b);
  }
}

[Top] [SubIndex]


一致した部分文字列 (Match())

using System;
using System.Text;
using System.Text.RegularExpressions;

public class MatchTest
{
  public static void Main()
  {
    var str = "127.0.0.1 - - [03/Mar/2014:08:21:37 +0900] \"GET /index.php HTTP/1.1\" 200 8095";
    var re = new Regex(@"\d+\.\d+\.\d\.\d");
    var m = re.Match(str);  // Match オブジェクトが返される。
    // パターンに一致するものがあれば、文字列内でのインデックスを表示する。
    if (m.Success)
      Console.WriteLine(m.Index);
  }
}

[Top] [SubIndex]


一致した部分文字列のコレクション (Matches())

using System;
using System.Text;
using System.Text.RegularExpressions;

public class MatchTest
{
  public static void Main()
  {
    var str = "127.0.0.1 - - [03/Mar/2014:08:21:37 +0900] \"GET /index.php HTTP/1.1\" 200 8095";
    var re = new Regex(@"\d+\.\d+\.\d\.\d");
    var m = re.Matches(str);  // MatchCollection オブジェクトが返される。
    // パターンに一致するものがあれば、その文字列を表示する。
    if (m.Count > 0)
    {
      foreach (var i in m)
        Console.WriteLine(i);
    }
  }
}

[Top] [SubIndex]


パターンに一致した部分文字列による分割 (Split())

using System;
using System.Text;
using System.Text.RegularExpressions;

public class SplitTest
{
  public static void Main()
  {
    var str = "127.0.0.1 - - [03/Mar/2014:08:21:37 +0900] \"GET /index.php HTTP/1.1\" 200 8095";
    var re = new Regex(@"\s");
    var ss = re.Split(str);  // string[] が返される。
    foreach (var s in ss)
      Console.WriteLine(s);
    // スタティックなメソッドもある。
    var ss2 = Regex.Split(@"\s", str);
    foreach (var s in ss)
      Console.WriteLine(s);
  }
}

[Top] [SubIndex]

 

パターンに一致した部分文字列の置換 (Replace())

using System;
using System.Text;
using System.Text.RegularExpressions;

public class ReplaceTest
{
  public static void Main()
  {
    var str = "127.0.0.1 - - [03/Mar/2014:08:21:37 +0900] \"GET /index.php HTTP/1.1\" 200 8095";
    var re = new Regex(@"\s");
    var s = re.Replace(str, "?");  // 置換された文字列が返される。
    Console.WriteLine(s);
    // スタティックなメソッドもある。
    s = Regex.Replace(str, @"\s", "?");  // 置換された文字列が返される。
    Console.WriteLine(s);
  }
}

[Top] [SubIndex]

 

 変換


キャストと as 演算子

using System;

public class CastTest
{
  public static void Main()
  {
    try
    {
       string s = (string)100;  // コンパイルエラーになる。
       Console.WriteLine(s);
       object o = 100 as object;  // これは可能。
       Console.WriteLine(o);
       string s2 = 100 as string;  // コンパイルエラーになる。。
       Console.WriteLine(s2);
    }
    catch
    {
       Console.WriteLine("キャストできません。");
    }
  }
}

[Top] [SubIndex]


Convert クラス

ConvertTo

using System;

public class ConverToTest
{
  public static void Main()
  {
     int i = Convert.ToInt32("123");
     Console.WriteLine(i);
     double x = Convert.ToDouble("1.23e-1");
     Console.WriteLine(x);
  }
}

Base64

using System;

public class Base64Test
{
  public static void Main()
  {
     string text = "大晦日 お正月 節分 ひな祭り";
     
     // 文字列をバイト配列に変換
     byte[] data = System.Text.Encoding.Default.GetBytes(text);
     // バイト配列を BASE64 に変換
     string str = Convert.ToBase64String(data);
     Console.WriteLine(str);
     
     // BASE64 文字列をバイト配列に変換
     data = Convert.FromBase64String(str);
     // バイト配列を文字列に変換
     string str2 = System.Text.Encoding.Default.GetString(data);
     Console.WriteLine(str2);
  }
}

[Top] [SubIndex]


Parse メソッド

※ Parse メソッドで変換に失敗すると例外が発生する。

using System;

public class ParseTest
{
  public static void Main()
  {
    var str = "598";
    var i = Int32.Parse(str);  // 整数に変換する。
    Console.WriteLine(i);
    str = "-5.698e-2";
    var x = Double.Parse(str);  // 浮動小数点数に変換する。
    Console.WriteLine(x);
  }
}

[Top] [SubIndex]


TryParse メソッド

TryParse メソッドは Parse メソッドと異なり、変換できない場合でも例外は発生しない。

using System;

public class ParseTest
{
  public static void Main()
  {
    int i;
    double x;
    var str = "598";
    if (Int32.TryParse(str, out i))
      Console.WriteLine(i);
    str = "-5.698e-2";
    if (Double.TryParse(str, out x))
      Console.WriteLine(x);
    str = null;
    if (Double.TryParse(str, out x))
      Console.WriteLine(x);
    else
      Console.WriteLine("変換不可。");
  }
}

[Top] [SubIndex]


ToString メソッド

using System;

public class ToStringTest
{
  public static void Main()
  {
     string str = 1.234.ToString();
     Console.WriteLine(str);
     str = true.ToString();
     Console.WriteLine(str);
  }
}

[Top] [SubIndex]


 ファイルシステム


ファイルを読み込むには

File クラスでファイルを読むためのメソッド

Encoding を指定しない場合は、文字コードは UTF8 とみなされることに注意。

using System;
using System.IO;
using System.Text;
using System.Collections;

public class FileRead
{
  public static void Main(string[] args)
  {
     if (args.Length == 0)
     {
        Console.WriteLine("パス名を指定してください。");
        return;
     }
     
     if (! File.Exists(args[0]))
     {
        Console.WriteLine(args[0] + " が存在しません。");
        return;
     }
     
     // ファイルをバイナリーデータとして読み込む。
     byte[] buffer = File.ReadAllBytes(args[0]);
     for (int i = 0; i < buffer.Length; i++)
     {
        Console.Write("{0:x2} ", buffer[i]);
     }
     
     Console.WriteLine();
     Console.ReadKey();
     
     // Windows で Shift_JIS ファイルを丸ごと文字列として読み込む。
     string content = File.ReadAllText(args[0], Encoding.Default);
     Console.WriteLine(content);
     
     // Windows で Shift_JIS ファイルを行単位で読み込む。
     string[] lines = File.ReadAllLines(args[0], Encoding.Default);
     foreach (var s in lines)
     {
        Console.WriteLine(s);
     }
     
     // Windows で Shift_JIS ファイルを列挙可能なオブジェクトとして読み込む。
     IEnumerable obj = File.ReadLines(args[0], Encoding.Default);
     foreach (var s in obj)
     {
        Console.WriteLine(s);
     }
  }
}

File クラスでストリームを使ってファイルを読むためのメソッド


using System;
using System.IO;
using System.Text;

public class Program
{
  public static void Main()
  {
    // ファイルを書き込み可能なモードで開いてストリームを得る。
    using (FileStream fs = File.Open("test.bin", FileMode.OpenOrCreate))
    {
      // バイトデータを書き込む。
      fs.Write(new byte[] {0x51, 0x52, 0x53, 0x54}, 0, 4);
      // ストリームを閉じる。
      fs.Close();
    }
    
    // ファイルを読み込みモードで開いてストリームを得る。
    byte[] buffer = new byte[4];
    using (FileStream fs = File.Open("test.bin", FileMode.Open))
    {
      // バッファにバイト単位で読み込む。
      fs.Read(buffer, 0, 4);
      fs.Close();
    }
    // 読み込んだデータを表示する。
    for (int i = 0; i < 4; i++)
    {
      Console.Write(buffer[i] + " ");
    }
  }
}

[Top] [SubIndex]


ファイルにデータを書き込むには

File クラスでファイルを書くためのメソッド

Encoding を指定しない場合は、文字コードは UTF8 とみなされることに注意。

テキストファイルの例

using System;
using System.IO;
using System.Text;
using System.Collections;

public class FileWrite
{
  public static void Main(string[] args)
  {
     if (args.Length == 0)
     {
        Console.WriteLine("パス名を指定してください。");
        return;
     }
     
     if (File.Exists(args[0]))
     {
        Console.WriteLine(args[0] + " が存在します。上書きしますか?(y/n)");
        var key = Console.ReadKey();
        if (key.KeyChar != 'y')
          return;
     }
     
     // Shift JIS でテキストの書き込み
     string[] buffer = new string[] { "新宿", "四谷", "御茶ノ水", "神田" };
     File.WriteAllLines(args[0], buffer, Encoding.Default);
     
     // メッセージ
     Console.WriteLine("\n書き込みが終了しました。");
  }
}

バイナリーファイルの例

using System;
using System.IO;
using System.Text;
using System.Collections;

public class FileWrite
{
  public static void Main(string[] args)
  {
     if (args.Length == 0)
     {
        Console.WriteLine("パス名を指定してください。");
        return;
     }
     
     if (File.Exists(args[0]))
     {
        Console.WriteLine(args[0] + " が存在します。上書きしますか?(y/n)");
        var key = Console.ReadKey();
        if (key.KeyChar != 'y')
          return;
     }
     
     // バイナリーファイルの書き込み
     byte[] buffer = new byte[] { 0x41, 0x42, 0x51, 0x52 };
     File.WriteAllBytes(args[0], buffer);
     
     // メッセージ
     Console.WriteLine("\n書き込みが終了しました。");
  }
}

File クラスでストリームを使ってファイルを書くためのメソッド

using System;
using System.IO;
using System.Text;
using System.Collections;

public class FileWrite
{
  public static void Main(string[] args)
  {
     if (args.Length == 0)
     {
        Console.WriteLine("パス名を指定してください。");
        return;
     }
     
     if (File.Exists(args[0]))
     {
        Console.WriteLine(args[0] + " が存在します。上書きしますか?(y/n)");
        var key = Console.ReadKey();
        if (key.KeyChar != 'y')
          return;
     }
     
     // ストリームを使ってバイナリーデータの書き込み
     byte[] buffer = new byte[] { 0x30, 0x33, 0x35, 0x39 };
     var fstream = File.Create(args[0]);
     fstream.Write(buffer, 0, buffer.Length);
     fstream.Close();
     
     // メッセージ
     Console.WriteLine("\n書き込みが終了しました。");
  }
}

[Top] [SubIndex]


ファイルの存在を判別するには

ファイルが存在するかどうかは File.Exists(path) メソッドを使う。path がディレクトリの場合には False になるので注意。

using System;
using System.IO;

public class FileTest1
{
  public static void Main(string[] args)
  {
     if (args.Length == 0)
     {
        Console.WriteLine("パス名を指定してください。");
        return;
     }
     
     if (! File.Exists(args[0]))
     {
        Console.WriteLine(args[0] + " が存在しません。");
        return;
     }
  }
}

[Top] [SubIndex]


ディレクトリを判別するには

あるパスが、ディレクトリかを判別するには Directory.Exists(path) メソッドを使う。

using System;
using System.IO;

public class IsDir
{
  public static void Main(string[] args)
  {
     if (args.Length == 0)
     {
        Console.WriteLine("パス名を指定してください。");
        return;
     }
     
     if (Directory.Exists(args[0]))
     {
        Console.WriteLine(args[0] + "はディレクトリです。");
     }
     else
     {
        Console.WriteLine(args[0] + "はディレクトリでないか存在しません。");
     }
  }
}

[Top] [SubIndex]


ファイルやディレクトリの属性を取得するには

File クラスのメソッドを使用するか、FileInfo クラスを利用する。ディレクトリに関しても、Directory クラスや DirectoryInfo クラスがある。

File クラスのメソッド

FileInfo クラスのプロパティ

Directory クラスのメソッド

DirectoryInfo クラスのプロパティ

File.GetAttributes(path) の使用例

using System;
using System.IO;

public class FileAttr
{
  public static void Main(string[] args)
  {
     if (args.Length == 0)
     {
        Console.WriteLine("パス名を指定してください。");
        return;
     }
     
     // パスの属性を得る。
     FileAttributes attr0 = File.GetAttributes(args[0]);
     
     // フラグがオフなら 0 を表示
     Console.WriteLine(attr & FileAttributes.Archive);
     Console.WriteLine(attr & FileAttributes.Compressed);
     Console.WriteLine(attr & FileAttributes.Device);
     Console.WriteLine(attr & FileAttributes.Directory);
     Console.WriteLine(attr & FileAttributes.Encrypted);
     Console.WriteLine(attr & FileAttributes.Hidden);
     Console.WriteLine(attr & FileAttributes.Normal);
     Console.WriteLine(attr & FileAttributes.ReadOnly);
     Console.WriteLine(attr & FileAttributes.System);
     Console.WriteLine(attr & FileAttributes.Temporary);
  }
}

FileInfo の使用例

using System;
using System.IO;

public class FileAttr
{
  public static void Main(string[] args)
  {
     if (args.Length == 0)
     {
        Console.WriteLine("パス名を指定してください。");
        return;
     }
     
     // パスの情報を得る。
     FileInfo fi = new FileInfo(args[0]);
     
     Console.WriteLine(fi.Exists);
     Console.WriteLine(fi.Attributes);  // FileAttributes 列挙体
  }
}

[Top] [SubIndex]


ファイルの日付を取得、変更するには

ファイルの日付を取得、変更するための File クラスのメソッドを以下に示す。

ファイルの日時を表示する例

using System;
using System.IO;

public class FileDate
{
  public static void Main(string[] args)
  {
     if (args.Length == 0)
     {
        Console.WriteLine("パス名を指定してください。");
        return;
     }
     
     if (! File.Exists(args[0]))
     {
        Console.WriteLine(args[0] + " が存在しません。");
        return;
     }
     
     // ファイルの作成日時
     var ct = File.GetCreationTime(args[0]);
     Console.WriteLine("{0:F}", ct);
     // ファイルの変更日時
     var cw = File.GetLastWriteTime(args[0]);
     Console.WriteLine("{0:F}", cw);
     // ファイルのアクセス日時
     var ca = File.GetLastAccessTime(args[0]);
     Console.WriteLine("{0:F}", ca);
  }
}

ファイルの日付を更新する例。

using System;
using System.IO;

public class Touch
{
  public static void Main(string[] args)
  {
     if (args.Length == 0)
     {
        Console.WriteLine("パス名を指定してください。");
        return;
     }
     
     if (! File.Exists(args[0]))
     {
        Console.WriteLine(args[0] + " が存在しません。");
        return;
     }
     
     // ファイルの変更日時を現在の日時にする。
     File.SetLastWriteTime(args[0], DateTime.Now);
     // 結果を表示する。
     var wt = File.GetLastWriteTime(args[0]);
     Console.WriteLine("{0:F}", wt);
  }
}

[Top] [SubIndex]


ディレクトリ内のファイル一覧を取得するには

ディレクトリ内のファイル一覧を取得するには、Directory クラスの以下のようなメソッドを使用する。

IEnumerable 型を返すバージョンもある。

ディレクトリ直下のファイルのみを列挙する。

using System; using System.IO; public class GetFilesTest { public static void Main(string[] args) { if (args.Length == 0) { Console.WriteLine("ディレクトリを指定してください。"); return; } if (! Directory.Exists(args[0])) { Console.WriteLine(args[0] + " が存在しません。"); return; } // パラメータで指定したディレクトリ内のファイルを列挙する。ディレクトリおよびサブディレクトリ内のファイルは含まれない。 string[] files = Directory.GetFiles(args[0]); foreach (var f in files) { Console.WriteLine(f); // f はフルパス、ABC 順にソートされる。 } } }

サブディレクトリ内のファイルを含むファイル一覧を取得する例

using System;
using System.IO;

public class GetFilesTest
{
  public static void Main(string[] args)
  {
     if (args.Length == 0)
     {
        Console.WriteLine("ディレクトリを指定してください。");
        return;
     }
     
     if (! Directory.Exists(args[0]))
     {
        Console.WriteLine(args[0] + " が存在しません。");
        return;
     }
     
     // パラメータで指定したディレクトリ内のファイルを列挙する。サブディレクトリ内のファイルを含む。
     string[] files = Directory.GetFiles(args[0], "*.exe", SearchOption.AllDirectories);
     
     foreach (var f in files)
     {
        Console.WriteLine(f);  // f はフルパス、ABC 順にソートされる。
     }
  }
}

指定されたディレクトリ直下のサブディレクトリのみを列挙する例

using System;
using System.IO;

public class GetDirectories
{
  public static void Main(string[] args)
  {
     if (args.Length == 0)
     {
        Console.WriteLine("ディレクトリを指定してください。");
        return;
     }
     
     if (! Directory.Exists(args[0]))
     {
        Console.WriteLine(args[0] + " が存在しません。");
        return;
     }
     
     // パラメータで指定したディレクトリ直下のサブディレクトリを列挙する。
     string[] files = Directory.GetDirectories(args[0]);
     
     foreach (var d in files)
     {
        Console.WriteLine(d);  // d はフルパス、ABC 順にソートされる。
     }
  }
}

指定されたディレクトリ直下のサブディレクトリとファイルを列挙する例

using System;
using System.IO;

public class GetEntries
{
  public static void Main(string[] args)
  {
     if (args.Length == 0)
     {
        Console.WriteLine("ディレクトリを指定してください。");
        return;
     }
     
     if (! Directory.Exists(args[0]))
     {
        Console.WriteLine(args[0] + " が存在しません。");
        return;
     }
     
     // パラメータで指定したディレクトリ直下のサブディレクトリとファイルを列挙する。
     string[] files = Directory.GetFileSystemEntries(args[0]);
     
     foreach (var d in files)
     {
        Console.WriteLine(d);  // d はフルパス、ABC 順にソートされる。
     }
  }
}

[Top] [SubIndex]


ドライブ一覧を取得するには

ドライブの情報は DriveInfo クラスにより取得できる。

using System;
using System.IO;

public class DriveInfoTest
{
  public static void Main()
  {
    // ドライブ一覧を取得する。
    DriveInfo[] drives = DriveInfo.GetDrives();
    
    // ドライブ情報を表示する。
    foreach (var drive in drives)
    {
       Console.WriteLine("{0} {1}", drive.Name, drive.DriveType);
    }
  }
}

実行例

A:\ Removable
C:\ Fixed
D:\ Fixed
J:\ CDRom

[Top] [SubIndex]


ファイルやディレクトリをリネームするには

Move メソッドを使うと、ファイルのリネーム(移動)を行うことができる。ディレクトリについても Move メソッドが用意されている。

using System;
using System.IO;

public class FileMove
{
  public static void Main(string[] args)
  {
     if (args.Length != 2)
     {
        Console.WriteLine("移動元と移動先のファイルを指定してください。");
        return;
     }
     
     if (! File.Exists(args[0]))
     {
        Console.WriteLine(args[0] + " が存在しません。");
        return;
     }
     
     // ファイルを移動(リネーム)する。
     File.Move(args[0], args[1]);
  }
}

ディレクトリの移動(リネーム)

using System;
using System.IO;

public class DirMove
{
  public static void Main(string[] args)
  {
     if (args.Length != 2)
     {
        Console.WriteLine("移動元と移動先のディレクトリを指定してください。");
        return;
     }
     
     if (! Directory.Exists(args[0]))
     {
        Console.WriteLine(args[0] + " が存在しません。");
        return;
     }
     
     // ディレクトリを移動(リネーム)する。
     Directory.Move(args[0], args[1]);
  }
}

[Top] [SubIndex]


ファイルやディレクトリを削除するには

ファイルやディレクトリを削除するには Delete メソッドを使用する。

using System;
using System.IO;

public class DeleteTest
{
  public static void Main(string[] args)
  {
     if (args.Length == 0)
     {
        Console.WriteLine("削除するファイルまたはディレクトリを指定してください。");
        return;
     }
     
     if (Directory.Exists(args[0]))
     {
        // ディレクトリの削除
        Directory.Delete(args[0], true);  // 第二引数が true の場合はディレクトリが空でなくても削除
     }
     else
     {
        // ファイルの削除
        File.Delete(args[0]);
     }
  }
}

[Top] [SubIndex]


ファイルコピーするには

ファイルコピーするには Copy メソッドを使用する。第一の形式ではファイルの上書きはできない。

using System;
using System.IO;

public class CopyFile
{
  public static void Main(string[] args)
  {
     if (args.Length != 2)
     {
        Console.WriteLine("コピー元とコピー先のパスを指定してください。");
        return;
     }
     
     if (! File.Exists(args[0]))
     {
        Console.WriteLine("コピー元のファイルが存在しません。");
        return;
     }
     
     File.Copy(args[0], args[1], true);  // 第3引数が true の場合、コピー先の上書きを許可。
  }
}

[Top] [SubIndex]


パス名の一部を取り出すには

Path クラスのメソッドを使うとパス名の一部を取り出すことができる。

using System;
using System.IO;

public class GetPathNameTest
{
  public static void Main(string[] args)
  {
     if (args.Length == 0)
     {
        Console.WriteLine("ファイルのパスを指定してください。");
        return;
     }
     string path = args[0];
     
     Console.WriteLine(Path.GetDirectoryName(path));  // ディレクトリ名を取得 (最後に \ は付かない)
     Console.WriteLine(Path.GetFileName(path));  // ファイル名を取得 (拡張子を含む)
     Console.WriteLine(Path.GetFileNameWithoutExtension(path));  // 拡張子を含まないファイル名を取得
     Console.WriteLine(Path.GetExtension(path));  // 拡張子を取得 (ドットを含む)
     Console.WriteLine(Path.GetPathRoot(path));  // ルートを取得 ("C:\" など)
  }
}

[Top] [SubIndex]


テンポラリファイル名を得るには

Path.GetTempFileName() を使うとテンポラリファイルの名前を得ることができる。Path.GetTempPath() を使うと一時フォルダのパスを得ることができる。

using System;
using System.IO;

public class TempPathTest
{
  public static void Main()
  {
     Console.WriteLine(Path.GetTempFileName());
     Console.WriteLine(Path.GetTempPath());
  }
}

実行例

C:\Users\user\AppData\Local\Temp\tmp2E0B.tmp
C:\Users\user\AppData\Local\Temp\

[Top] [SubIndex]


フルパス(絶対パス)を得るには

Path.GetFullPath(path) メソッドを使うとフルパスを取得できる。

using System;
using System.IO;

public class GetPathNameTest
{
  public static void Main(string[] args)
  {
     if (args.Length == 0)
     {
        Console.WriteLine("ファイルのパスを指定してください。");
        return;
     }
     
     // 絶対パスを表示
     Console.WriteLine(Path.GetFullPath(args[0]));
  }
}

[Top] [SubIndex]


ファイルの拡張子を変更するには

ファイルの拡張子を変更するには、Path.ChangeExtension メソッドで拡張子を変更した場合のパス名を取得してから、File.Moveメソッドでリネームを行う。

using System;
using System.IO;

public class ChangeExt
{
  public static void Main(string[] args)
  {
     if (args.Length == 0)
     {
        Console.WriteLine("ファイルのパスを指定してください。");
        return;
     }
     
     // 拡張子を .bak にしたパス名を取得
     Console.WriteLine(Path.ChangeExtension(args[0], ".bak"));
  }
}

[Top] [SubIndex]


カレントディレクトリを取得、変更するには

Directory.GetCurrentDirectory() メソッドを使うとカレントディレクトリのパス名を得ることができる。Directory.SetCurrentDirectory(path) メソッドを使うと、カレントディレクトリを変更できる。

using System;
using System.IO;

public class CurrentDir
{
  public static void Main(string[] args)
  {
     if (args.Length == 0)
     {
        Console.WriteLine("ディレクトリを指定してください。");
        return;
     }
     
     // カレントディレクトリを変更
     Directory.SetCurrentDirectory(args[0]);
     // カレントディレクトリを表示
     Console.WriteLine(Directory.GetCurrentDirectory());
  }
}

[Top] [SubIndex]


非同期でファイルを読み書きするには

File.Open メソッドや File.OpenText メソッドでストリームを開いて、ストリームの ReadSync メソッドを使用する。

[Top] [SubIndex]

 

 ストリーム


テキストファイルを読み書きするには

テキストファイルを読み書きするには、StreamReader, StreamWriter クラスを使用する。下のサンプルでは UTF-8 のファイルの読み書きをしているが、Windows のテキストファイルの場合は、Shift_JIS なので Encoding.UTF8 の代わりに Encoding.Default または Encoding.GetEncoding("Shift_JIS") とする。

この例では、ストリームを作成するのにコンストラクタを new でインスタンス化しているが、代わりに File クラスの OpenText メソッドを使うこともできる。

using System;
using System.Text;
using System.IO;

public class Program
{
  public static void Main()
  {
    using (StreamWriter sw = new StreamWriter("test.txt", false, Encoding.UTF8))
    {
      sw.WriteLine("あいうえお");
      sw.WriteLine("1234567890");
      sw.Close();
    }
    
    using (StreamReader sr = new StreamReader("test.txt", Encoding.UTF8))
    {
      string s;
      while ((s = sr.ReadLine()) != null)
      {
        Console.WriteLine(s);
      }
      sr.Close();
    }
  }
}

[Top] [SubIndex]


バイナリーファイルを読み書きするには

バイナリーファイルを読み書きするには BinaryReader、BinaryWriter クラスを使用する。FileStream を使うと読み書きが同時にできる。(サンプルはこちら)

using System;
using System.IO;

public class Program
{
  public static void Main()
  {
    using (BinaryWriter writer1 = new BinaryWriter(File.Open("test.bin", FileMode.OpenOrCreate)))
    {
      writer1.Write(new byte[]{0x30, 0x31, 0x32, 0x33});
      writer1.Close();
    }
    
    using (BinaryReader reader1 = new BinaryReader(File.Open("test.bin", FileMode.Open)))
    {
      byte[] buffer = reader1.ReadBytes(4);
      reader1.Close();
      
      foreach (byte b in buffer)
      {
        Console.Write(b);
        Console.Write(' ');
      }
    }
    
    Console.WriteLine();
  }
}

[Top] [SubIndex]


メモリに対して読み書きするには

ファイルの代わりにメモリに対して読み書きするには、MemoryStream クラスを使用する。

using System;
using System.IO;

public class Program
{
  public static void Main()
  {
    using (MemoryStream ms = new MemoryStream(1024))
    {
      byte[] buffer = new byte[] {0x40, 0x41, 0x42, 0x43, 0x44, 0x45};
      ms.Write(buffer, 0, buffer.Length);
      ms.Write(buffer, 0, buffer.Length);
      ms.Write(buffer, 0, buffer.Length);
      
      ms.Seek(0, SeekOrigin.Begin);
      
      byte[] buffer2 = new byte[1024];
      int n = ms.Read(buffer2, 0, buffer2.Length);
      Console.WriteLine("length=" + n);
      
      for (int i = 0; i < n; i++)
      {
        Console.Write(buffer2[i]);
        Console.Write(' ');
      }
      
      ms.Close();
    }
    
    Console.WriteLine();
  }
}

[Top] [SubIndex]


ファイルを非同期で読み書きするには

ファイルを非同期で読み書きするには、ReadAsync, WriteAsync など Async が付いたメソッドを使用する。(CLR 4.5 以上の場合のみ動作)

using System;
using System.IO;
using System.Threading;

public class AsyncTest
{
  public static void Main()
  {
     WriteData();
     // ファイルへの書き込みは別スレッドで実行されるので、書き込みが終わる前に ReadData() が実行される。
     // そのため、少しの待ちを入れている。
     Thread.Sleep(10);
     // ファイルへの読み込みは別スレッドで実行されるので、書き込みが終わる前に ReadData() が実行される。
     // そのため、少しの待ちを入れている。
     ReadData();
     Thread.Sleep(10);
  }
  
  // 非同期でデータを書く。(別スレッドで動作)
  public static async void WriteData()
  {
     var buffer = new byte[] { 0x30, 0x31, 0x32, 0x33, 0x41, 0x42, 0x43, 0x44 };
     
     using(var fs = File.Open("test.bin", FileMode.OpenOrCreate))
     {
        await fs.WriteAsync(buffer, 0, 8);  // buffer にデータの書き込みが完了するまでブロックされる。
     }
     
     Console.WriteLine("Writing finished.");
  }
  
  // 非同期でデータを読む。(別スレッドで動作)
  public static async void ReadData()
  {
     var buffer = new byte[8];
     
     using(var fs = File.Open("test.bin", FileMode.OpenOrCreate))
     {
        await fs.ReadAsync(buffer, 0, 8);   // buffer にデータの読み込みが完了するまでブロックされる。
     }
     
     for (int i = 0; i < 8; i++)
     {
        Console.Write("{0:x2} ", buffer[i]);
     }
     Console.WriteLine();
     Console.WriteLine("Reading finished.");
  }
}

CLR 4.0 以前では async /await は使用できないので、BeginRead, EndRead メソッドなどを利用する。

using System;
using System.IO;
using System.Threading;

// CLR 4.0 以前
public class AsyncTest
{
  static ManualResetEvent event1;   // I/O 完了待ち用同期イベント
  static byte[] buffer;  // 入出力バッファ
  
  static void Main()
  {
     event1 = new ManualResetEvent(false);
     // 非同期で書く
     WriteData();
     // 非同期で読む
     ReadData();
  }
  
  // 非同期でデータを書く。(別スレッドで動作)
  static void WriteData()
  {
     // バッファにデータをセットする。
     buffer = new byte[] { 0x35, 0x36, 0x37, 0x38, 0x45, 0x46, 0x47, 0x48 };
     using(var fs = File.Open("test.bin", FileMode.OpenOrCreate))
     {
        event1.Set();  // イベントをシグナル状態にする。
        // 非同期書き込みを開始する。
        var ar = fs.BeginWrite(buffer, 0, 8, CallbackWrite, buffer);
        event1.WaitOne(); // Await
        fs.EndWrite(ar);  // 非同期書き込みを終える。
     }
  }
  
  // 非同期でデータを読む。(別スレッドで動作)
  static void ReadData()
  {
     using(var fs = File.Open("test.bin", FileMode.OpenOrCreate))
     {
        // バッファをクリアする。
        buffer = new byte[8] {0, 0, 0, 0, 0, 0, 0, 0};
        event1.Set();  // イベントをシグナル状態にする。
        // 非同期読み込みを開始する。
        var ar = fs.BeginRead(buffer, 0, 8, CallbackRead, null);
        event1.WaitOne();  // Await
        fs.EndRead(ar);  // 非同期読み込みを終える。
        // 読み込んだデータを表示する。
        for (int i = 0; i < 8; i++)
        {
           Console.Write("{0:x2} ", buffer[i]);
        }
        Console.WriteLine("\nReading finished.");
     }
  }
  
  // 読み込みが完了したとき呼び出されるコールバックメソッド
  static void CallbackRead(IAsyncResult ar)
  {
     event1.Reset();  // 非シグナル状態にする。
  }
  
  // 書き込みが完了したとき呼び出されるコールバックメソッド
  static void CallbackWrite(IAsyncResult ar)
  {
     event1.Reset();  // 非シグナル状態にする。
     Console.WriteLine("Writing finished.");
  }
}

[Top] [SubIndex]

 

 プロセス


プロセスを起動するには

プロセスを起動するには、Process クラスの StartInfo プロパティに値を設定して、Start() メソッドを呼び出す。

using System;
using System.Diagnostics;

public class ProcessTest
{
  public static void Main(string[] args)
  {
     if (args.Length == 0)
     {
        Console.WriteLine("起動するプログラムを指定してください。");
        return;
     }
     
     var process = new Process();
     
     // 実行するファイルのパス
     process.StartInfo.FileName = args[0];
     if (args.Length > 1)
     {
        // 引数があれば設定する。
        process.StartInfo.Arguments = args[1];  // ただし、引数が1つのときのみ有効 (複数あるときは連結する)
     }
     
     // 開始
     process.Start();
  }
}

[Top] [SubIndex]


ウィンドウを作成せずにプロセスを起動するには

StartInfo.CreateNoWindow プロパティを true にすることにより、プロセスを起動したときウィンドウは新しく作成されない。


ウィンドウのスタイルを指定するには

StartInfo.WindowStyle プロパティを設定すると新しいウィンドウを最大化、最小化して表示できる。


ワークディレクトリを指定するには

StartInfo.WorkingDirectory にワークディレクトリを指定すると、そのディレクトリ上でプロセスが起動する。

[Top] [SubIndex]


プロセスを終了させるには

プロセスを終了させるには Kill() メソッドを使用する。実際にプロセスが終了するのは、非同期なので、WaitForExit() や HasExit() メソッドを使って終了まで待つ必要がある。

using System;
using System.Diagnostics;
using System.Threading;

public class KillProcess
{
  public static void Main(string[] args)
  {
     if (args.Length == 0)
     {
        Console.WriteLine("起動するプログラムを指定してください。");
        return;
     }
     
     var process = new Process();
     
     // 実行するファイルのパス
     process.StartInfo.FileName = args[0];
     if (args.Length > 1)
     {
        // 引数があれば設定する。
        process.StartInfo.Arguments = args[1];  // ただし、引数が1つのときのみ有効 (複数あるときは連結する)
     }
     
     // 開始
     process.Start();
     
     // Killするまで、1秒待つ。
     Thread.Sleep(1000);
     
     // 終了
     process.Kill();
     // プロセスは非同期で終了するので、終了まで待つ。
     process.WaitForExit();
  }
}

[Top] [SubIndex]


プロセス一覧を取得するには

プロセスの一覧を取得するには、GetProcesses() メソッドを使用する。

using System;
using System.Diagnostics;

public class KillProcess
{
  public static void Main()
  {
     // 現在のプロセス
     var proc = Process.GetCurrentProcess();
     Console.WriteLine("CurrentProcess = {0} {1}", proc.Id, proc.ProcessName);
     
     // プロセス一覧
     var procs = Process.GetProcesses();
     foreach (var p in procs)
     {
        Console.WriteLine("{0} - {1} - {2}", p.Id, p.ProcessName, p.MainWindowTitle);
     }
  }
}

[Top] [SubIndex]


プロセスの状態を取得するには

プロセスが終了したかどうかは、HasExited プロパティで知ることができる。プロセスの終了コードは、ExitCode プロパティで取得する。

using System;
using System.Diagnostics;
using System.Threading;

public class ProcessStatus
{
  public static void Main(string[] args)
  {
     if (args.Length == 0)
     {
        Console.WriteLine("起動するプログラムを指定してください。");
        return;
     }
     
     var process = new Process();
     
     // 実行するファイルのパス
     process.StartInfo.FileName = args[0];
     
     // 開始
     process.Start();
     
     // 終わるまで、1秒待つ。
     Thread.Sleep(1000);
     
     // 終わってなければ強制終了
     if (process.HasExited == false)
        process.Kill();
        
     // プロセスは非同期で終了するので、終了まで待つ。
     while (process.HasExited == false)
       Thread.Sleep(100);
       
     // 終了コード
     Console.WriteLine("Exit Code = {0}", process.ExitCode);
  }
}

[Top] [SubIndex]


プロセスの標準入出力をリダイレクトするには

下の例は、プロセスの標準出力をリダイレクトして文字列として取得するものである。

process1.StartInfo.UseShellExecute = false;
process1.StartInfo.CreateNoWindow = true;
process1.StartInfo.RedirectStandardOutput = true;
process1.Start();
var str = process1.StandardOutput.ReadToEnd();
process1.WaitForExit();
var fm = new Form2(str);
fm.Show();

[Top] [SubIndex]


プロセスの同期

Mutex を使うとプロセスの同期を取ることができる。また、同じアプリケーションの二重起動のチェックにも使用できる。

// 二重起動チェック
const string MutexName = "MyApp";
var mutex1 = new Mutex(true, MutexName);
if (! mutex1.WaitOne(1))
{
  if (MessageBox.Show("他に実行中のインスタンスがあります。続行しますか?", "注意", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.No)
  {
     return;
  }
}

[Top] [SubIndex]


名前なしパイプ

名前なしパイプは、親子プロセス間で使用する。

using System;
using System.Text;
using System.IO;
using System.IO.Pipes;
using System.Diagnostics;

namespace AnonymousPipeTest
{
    /// <summary>
    /// 匿名パイプクラス
    /// </summary>
    /// <remarks>片方向への送受信しかできないので注意。</remarks>
    public class PipeAnon
    {
        private AnonymousPipeServerStream pipeServer;   // サーバ
        private AnonymousPipeClientStream pipeClient;   // クライアント
        
        /// <summary>
        /// コンストラクタ (サーバ用)
        /// </summary>
        /// <param name="direction">PipeDirection.InまたはPipeDirection.Outを指定する。</param>
        public PipeAnon(PipeDirection direction = PipeDirection.Out)
        {
            // HandleInheritability.Inheritableを指定しないとパイプハンドルが子プロセスに継承できないので注意。
            pipeServer = new AnonymousPipeServerStream(direction, HandleInheritability.Inheritable);
        }
        
        /// <summary>
        /// コンストラクタ (クライアント用)
        /// </summary>
        /// <param name="PipeHandle">パイプハンドル。サーバのGetClientHandleAsString()メソッドで取得する。</param>
        /// <param name="direction">PipeDirection.InまたはPipeDirection.Outを指定する。</param>
        public PipeAnon(string PipeHandle, PipeDirection direction = PipeDirection.In)   
        {
            pipeClient= new AnonymousPipeClientStream(direction, PipeHandle);
        }
        
        /// <summary>
        /// パイプハンドル(子プロセスのパラメータとして渡す)
        /// </summary>
        public string PipeHandleString
        {
            get
            {
                return pipeServer.GetClientHandleAsString();
            }
        }
        
        /// <summary>
        /// パイプの繋ぎ先の子プロセスを起動する。
        /// </summary>
        /// <param name="path">起動する子プロセスのパス名。nullの場合は自分自身。</param>
        /// <param name="ShellExecute">Shell内で実行するかどうかを指定する。falseにす るとコンソール画面が表示されない。</param>
        /// <returns>起動したプロセス</returns>
        /// <remarks>
        /// Debugモードではアプリ名.vshost.exeが実行されるため正しく動作しない。
        /// path=nullのとき、カレントディレクトリにコマンド(.exe)が置いてある必要があ る。
        /// </remarks>
        public Process StartChildProcess(string path = null)
        {
            var child = new Process();
            
            if (path == null)
            {
                path = System.Environment.CommandLine;
            }
            child.StartInfo.FileName = path;
            child.StartInfo.Arguments = PipeHandleString;
            child.StartInfo.UseShellExecute = false;  // trueではパイプハンドルが無効 になるので注意
            child.Start();
            return child;
        }
        
        /// <summary>
        /// クライアント(子プロセス)へメッセージを送る。
        /// </summary>
        /// <param name="msg"></param>
        public void SendToClient(string msg)
        {
            byte[] buffer = Encoding.UTF8.GetBytes(msg);
            pipeServer.Write(buffer, 0, buffer.Length);
            pipeServer.Flush();
            pipeServer.WaitForPipeDrain();
        }
        
        /// <summary>
        /// サーバ(親プロセス)へメッセージを送る。
        /// </summary>
        /// <param name="msg"></param>
        public void SendToServer(string msg)
        {
            byte[] buffer = Encoding.UTF8.GetBytes(msg);
            pipeClient.Write(buffer, 0, buffer.Length);
            pipeClient.WaitForPipeDrain();
        }
        
        /// <summary>
        /// サーバ(親プロセス)からのメッセージを受信する。
        /// </summary>
        /// <returns></returns>
        public string ReceiveFromServer()
        {
            byte[] buffer = new byte[1024];
            pipeClient.Read(buffer, 0, 1024);
            return Encoding.UTF8.GetString(buffer);
        }
        
        /// <summary>
        /// クライアント(子プロセス)からのメッセージを受信する。
        /// </summary>
        /// <returns></returns>
        public string ReceiveFromClient()
        {
            byte[] buffer = new byte[1024];
            pipeServer.Read(buffer, 0, 1024);
            return Encoding.UTF8.GetString(buffer);
        }
        
        /// <summary>
        /// パイプを閉じる。
        /// </summary>
        public void Close()
        {
            pipeServer.Close();
        }
    }
}

[Top] [SubIndex]


名前付きパイプ

名前付きパイプはプロセス間でデータを交換するのに使用する。

using System;

namespace NamedPipeTest
{
    class Program
    {
        /// <summary>
        /// 名前付きパイプのテスト
        /// </summary>
        /// <param name="args"></param>
        static void Main(string[] args)
        {
            string msg;
            
            if (args.Length == 0)
            {
                Console.WriteLine("使用方法: NamedPipeTest.exe -c|-s|-C|-S pipe_name");
            return;
            }
            
            if (args[0] == "-s")
            {
                // 出力サーバとして動作
                Console.WriteLine("-- NamedPipe Server Output --");
                var server = new PipeNamed(args[1], System.IO.Pipes.PipeDirection.Out, false);
                server.SendToClient("Hello World!");
                Console.WriteLine("Message sent.");
            }
            else if (args[0] == "-c")
            {
                // 入力クライアントとして動作
                Console.WriteLine("-- NamedPipe Client Input --");
                var client = new PipeNamed(args[1], System.IO.Pipes.PipeDirection.In, true);
                msg = client.ReceiveFromServer();
                Console.WriteLine(msg);
            }
            if (args[0] == "-S")
            {
                // 入力サーバとして動作
                Console.WriteLine("-- NamedPipe Server Input --");
                var server = new PipeNamed(args[1], System.IO.Pipes.PipeDirection.In, false);
                msg = server.ReceiveFromClient();
                Console.WriteLine(msg);
            }
            else if (args[0] == "-C")
            {
                // 出力クライアントとして動作
                Console.WriteLine("-- NamedPipe Client Output --");
                var client = new PipeNamed(args[1], System.IO.Pipes.PipeDirection.Out, true);
                client.SendToServer("Hello World!");
                Console.WriteLine("Message sent.");
            }
            else
            {
                Console.WriteLine("不正なコマンド引数が指定された。");
            }
        }
    }
}

using System.Text;
using System.IO.Pipes;

namespace NamedPipeTest
{
    /// <summary>
    /// 名前付きパイプクラス
    /// </summary>
    /// <remarks>
    /// ローカルマシンのプロセスどうしで名前付きパイプをつないでメッセージのやりとりをする。
    /// </remarks>
    public class PipeNamed
    {
        private NamedPipeServerStream pipeServer = null;  // サーバパイプ
        private NamedPipeClientStream pipeClient = null;  // クライアントパイプ
        
        /// <summary>
        /// コンストラクタ
        /// </summary>
        /// <param name="name">パイプの名前</param>
        /// <param name="direction">パイプの方向</param>
        /// <param name="client">trueならクライアントとして動作</param>
        public PipeNamed(string name, PipeDirection direction = PipeDirection.Out, bool client = false)
        {
            if (client)
            {
                // クライアントパイプを作成して接続する。
                pipeClient = new NamedPipeClientStream(".", name, direction);  // "."はローカルマシンを意味する。
                pipeClient.Connect();
            }
            else
            {
                // サーバパイプを作成して接続待ちにする。
                pipeServer = new NamedPipeServerStream(name, direction);
                pipeServer.WaitForConnection();
            }
        }
        
        /// <summary>
        /// クライアントへメッセージを送る。(サーバとして動作している場合)
        /// </summary>
        /// <param name="msg"></param>
        public void SendToClient(string msg)
        {
            byte[] buffer = Encoding.UTF8.GetBytes(msg);
            pipeServer.Write(buffer, 0, buffer.Length);
            pipeServer.Flush();
            pipeServer.WaitForPipeDrain();  // クライアントがパイプを読むまで待つ。
        }
        
        /// <summary>
        /// クライアントからメッセージを受信する。(サーバとして動作している場合)
        /// </summary>
        /// <param name="bytes">メッセージの最大バイト数</param>
        /// <returns></returns>
        public string ReceiveFromClient(int bytes = 1024)
        {
            byte[] buffer = new byte[bytes];
            int n = pipeServer.Read(buffer, 0, buffer.Length);
            string str = Encoding.UTF8.GetString(buffer, 0, n);
            return str;
        }
        
        /// <summary>
        /// サーバへメッセージを送る。(クライアントとして動作している場合)
        /// </summary>
        /// <param name="msg"></param>
        public void SendToServer(string msg)
        {
            byte[] buffer = Encoding.UTF8.GetBytes(msg);
            pipeClient.Write(buffer, 0, buffer.Length);
            pipeClient.Flush();
            pipeClient.WaitForPipeDrain();
        }
        
        /// <summary>
        /// サーバからメッセージを受信する。(クライアントとして動作している場合)
        /// </summary>
        /// <param name="bytes">メッセージの最大バイト数</param>
        /// <returns></returns>
        public string ReceiveFromServer(int bytes = 1024)
        {
            byte[] buffer = new byte[bytes];
            int n = pipeClient.Read(buffer, 0, buffer.Length);
            string str = Encoding.UTF8.GetString(buffer, 0, n);
            return str;
        }
        
        /// <summary>
        /// パイプを閉じる。
        /// </summary>
        public void Close()
        {
            if (pipeServer != null)
                pipeServer.Close();
            if (pipeClient != null)
                pipeClient.Close();
        }       
    }
}

[Top] [SubIndex]


共有メモリ (MemoryMappedFile)

MemoryMappedFile クラスを使うとプロセス間で有効な共有メモリを実現できる。

using System;
using System.IO;
using System.IO.MemoryMappedFiles;
using System.Text;
using System.Threading;

/// <summary>
/// 非永続化メモリマップトファイル(共有メモリ)
/// </summary>
class Program
{
    static void Main(string[] args)
    {
        const long MMFSize = 1024L;
        const string MutexName = "MemoryMappedFiles";
        const string MmfName = "Memory Mapped File";
        MemoryMappedFile mmf;
        Mutex mutex1;
        bool owned = false;
        Stream stream;
        byte[] buffer;
        
        if (args.Length == 0)
        {
            Console.WriteLine(@"使用方法: MemoryMappedFile.exe -c|-o
-c: 新しく共有メモリを作成する。
-o: 既存の共有メモリを開く。
");
            return;
}
        else if (args[0] == "-c")
        {
            mutex1 = new Mutex(true, MutexName, out owned);  // シグナル状態で作成
            
            // すでに存在する場合はエラーにする。
            if (! owned)
            {
                Console.WriteLine("エラー:すでに同じミューテックスが存在します。");
                return;
            }
            
            // 新しく共有メモリを作成する。
            try
            {
               using (mmf = MemoryMappedFile.CreateNew(MmfName, MMFSize, MemoryMappedFileAccess.ReadWrite))
                {
                    // データを書き込む。
                    stream = mmf.CreateViewStream(0, MMFSize, MemoryMappedFileAccess.ReadWrite);
                    buffer = new byte[] { 0x41, 0x42, 0x43, 0x44, 0x45 };
                    stream.Write(buffer, 0, 5);
                    stream.Close();
                    Console.WriteLine("共有メモリに書き込みました。\n受信側を起動してください。>");
                    mutex1.ReleaseMutex();
                    Console.ReadKey();
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
                mutex1.Close();
            }
        }
        else if (args[0] == "-o")
        {
            mutex1 = new Mutex(); // 非シグナル状態で作成
            mutex1.WaitOne();  // シグナル状態になるまで待つ。
            
            try
            {
                // 既存の共有メモリを開く。
                using (mmf = MemoryMappedFile.OpenExisting(MmfName))
                {
                    stream = mmf.CreateViewStream(0, MMFSize, MemoryMappedFileAccess.ReadWrite);
                    buffer = new byte[MMFSize];
                    stream.Read(buffer, 0, (int)MMFSize);
                    Console.WriteLine(Encoding.ASCII.GetString(buffer, 0, 5));
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
            finally
            {
                mutex1.Close();
            }
        }
        else
        {
            Console.WriteLine("不正なパラメータが指定されました。-c または -o のみ有効です。");
        }
}
}

[Top] [SubIndex]

 

 スレッド

パラメータなしスレッドの場合

using System;
using System.Threading;

public class ThreadTest1
{
  public static void Main()
  {
    // Thread コンストラクタに ThreadStart デリゲートをパラメータとして渡す。
    //   [ComVisibleAttribute(true)]
    //   public delegate void ThreadStart()
    Thread thread1 = new Thread(DoWork);
    Thread thread2 = new Thread(DoWork);
    // スレッド開始
    thread1.Start();
    thread2.Start();
  }
  
  // ThreadStart デリゲートに使用するメソッド
  // 
  public static void DoWork()
  {
    for (int i = 0; i < 5; i++)
    {
      Console.WriteLine(i);
      Thread.Sleep(300);  // 300 ms スリープ
    }
  }
}

[Top] [SubIndex]


パラメータありスレッドの場合 (スレッド用クラスを作る)

using System;
using System.Threading;

public class ThreadTest2
{
  public static void Main()
  {
    MyThread thread1 = new MyThread(10);
    MyThread thread2 = new MyThread(4);
  }
}

// スレッドにパラメータを与えるためのクラス
class MyThread
{
  private Thread thread;
  private int count;
  
  public MyThread(int n)
  {
    if (n <= 0)
    {
      count = 10;
    }
    else
    {
      count = n;
    }
    
    this.thread = new Thread(new ThreadStart(Run));
    this.thread.Start();
  }
  
  public void Run()
  {
    while (true)
    {
      count--;
      if (count < 0)
      {
        return;
      }
      Console.WriteLine(count);
      Thread.Sleep(500);
    }
  }
}

[Top] [SubIndex]


スレッド用基底ファイルを作る例

using System;
using System.Threading;

public abstract class Runnable
{
  public Thread thread;
  
  public Runnable() {
    this.thread = new Thread(new ThreadStart(Run));
  }
  
  public Runnable(string name)
  {
    this.thread = new Thread(new ThreadStart(Run));
    this.thread.Name = name;
  }
  
  public void Start()  {
    this.thread.Start();
  }
  
  public string Name
  {
    get { return this.thread.Name; }
  }
  
  protected abstract void Run();
}


public class ThreadTest3
{
  public static void Main()
  {
    MyThread thread1 = new MyThread(10);
    MyThread thread2 = new MyThread(4);
  }
}

class MyThread : Runnable
{
  private int count;
  
  public MyThread(int n) : base("id" + n)
  {
    if (n <= 0)
    {
      count = 10;
    }
    else
    {
      count = n;
    }
    
    this.Start();
  }
  
  protected override void Run()
  {
    while (true)
    {
      count--;
      if (count < 0)
      {
        return;
      }
      Console.WriteLine(this.Name + " = " + count);
      Thread.Sleep(500);
    }
  }
}

[Top] [SubIndex]


ParameterizedThreadStart デリゲートを使う例

using System;
using System.Threading;

public class ParamThreadTest1
{
  public static void Main()
  {
    ParameterizedThreadStart workerDelegate = new ParameterizedThreadStart(DoWork);
    Thread thread = new Thread(workerDelegate);
    thread.Start(10);  // パラメータをStartメソッドで渡す。
  }
  
  public static void DoWork(object data)
  {
    int count = (int)data;
    
    while (true)
    {
      count--;
      if (count < 0)
      {
        return;
      }
      
      Console.WriteLine(count);
      Thread.Sleep(500);
    }
  }
}

[Top] [SubIndex]


スレッドが生きているか判別するには

IsAlive プロパティを使うと、スレッドがまだ実行中かを知ることができる。

using System;
using System.Threading;

public class ParamThreadTest2
{
  public static void Main()
  {
    ParameterizedThreadStart workerDelegate = new ParameterizedThreadStart(DoWork);
    Thread thread = new Thread(workerDelegate);
    thread.Start(10);  // パラメータをStartメソッドで渡す。
    
    while (thread.IsAlive)
    {
      Thread.Sleep(250);
    }
    
    Console.WriteLine("スレッド終了");
  }
  
  public static void DoWork(object data)
  {
    int count = (int)data;
    
    while (true)
    {
      count--;
      if (count < 0)
      {
        return;
      }
      
      Console.WriteLine(count);
      Thread.Sleep(500);
    }
  }
}

[Top] [SubIndex]


メインスレッドをブロックするには

Join() メソッドを使うと、スレッドが終了するまで呼び出し元のスレッドをブロックする。

using System;
using System.Threading;

public class ParamThreadTest3
{
  public static void Main()
  {
    ParameterizedThreadStart workerDelegate = new ParameterizedThreadStart(DoWork);
    Thread thread = new Thread(workerDelegate);
    thread.Start(10);  // パラメータをStartメソッドで渡す。
    thread.Join();    // メインスレッドをブロックする
    Console.WriteLine("スレッド終了");
  }
  
  public static void DoWork(object data)
  {
    int count = (int)data;
    
    while (true)
    {
      count--;
      if (count < 0)
      {
        return;
      }
      
      Console.WriteLine(count);
      Thread.Sleep(500);
    }
  }
}

[Top] [SubIndex]


lock を使ってクリティカルセクションを実現するには

lock キーワードを使うとクリティカルセクションを実現できる。

using System;
using System.Threading;

public class LockSample1
{
  public static ClsObject object1;
  
  public static void Main()
  {
    object1 = new ClsObject();
    
    ThreadStart worker1 = new ThreadStart(DoWork1);
    ThreadStart worker2 = new ThreadStart(DoWork2);
    Thread thread1 = new Thread(worker1);
    Thread thread2 = new Thread(worker2);
    
    thread1.Start();
    thread2.Start();
    thread1.Join();
    thread2.Join();
    
    Console.WriteLine("スレッド終了");
  }
  
  public static void DoWork1()
  {
    for (int i = 0; i < 10; i++)
    {
      // object1 をロックして他のスレッドが同時に実行できないようにする。
      lock (object1)
      {
        object1.Message = "*** ワーカー1 ***";
      }
    }
  }
  
  public static void DoWork2()
  {
    for (int i = 0; i < 5; i++)
    {
      // object1 をロックして他のスレッドが同時に実行できないようにする。
      lock (object1)
      {
        object1.Message = "((( ワーカー2 )))";
      }
    }
  }
}


// ロックオブジェクト用のクラス
public class ClsObject
{
  public string message;
  
  public ClsObject()
  {
    this.message = "no message";
  }
  
  public string Message
  {
    get { return this.message;}
    
    set
    {
      this.message = value;
      Console.WriteLine(this.message);
      Thread.Sleep(500);
    }
  }
}

[Top] [SubIndex]


スレッドの同期を取るには

自動

AutoResetEvent クラスを使うと、自動でリセットされるイベントによりスレッド間で同期を取ることができる。

using System;
using System.Threading;

public class AutoResetEventSample
{
  static AutoResetEvent event1;
  
  public static void Main()
  {
    Thread thread1 = new Thread(DoWork1);
    Thread thread2 = new Thread(DoWork2);
    event1 = new AutoResetEvent(false);
    thread1.Start();
    thread2.Start();
    thread1.Join();
    thread2.Join();
    
    Console.WriteLine("終了");
  }
  
  public static void DoWork1()
  {
    Console.WriteLine("DoWork1はシグナル待ちです。");
    event1.WaitOne();
    Console.WriteLine("DoWork1はシグナルを受け取りました。");
  }
  
  public static void DoWork2()
  {
    Thread.Sleep(1000);
    Console.WriteLine("DoWork2はシグナルを送りました。");
    event1.Set();
  }
}

手動

ManualResetEvent クラスを使うと、手動でスレッド間で同期を取ることができる。ManualResetSlim クラス (タイマーの使用例) もある。

using System;
using System.Threading;

public class AutoResetEventSample
{
  static ManualResetEvent event1;
  
  public static void Main()
  {
    Thread thread1 = new Thread(DoWork1);
    Thread thread2 = new Thread(DoWork2);
    Thread thread3 = new Thread(DoWork3);
    event1 = new ManualResetEvent(false);
    thread1.Start();
    thread2.Start();
    thread3.Start();
    thread1.Join();
    thread2.Join();
    thread3.Join();
    
    Console.WriteLine("終了");
  }
  
  public static void DoWork1()
  {
    Console.WriteLine("DoWork1はシグナル待ちです。");
    event1.WaitOne();
    Console.WriteLine("DoWork1はシグナルを受け取りました。");
  }
  
  public static void DoWork2()
  {
    Console.WriteLine("DoWork2はシグナル待ちです。");
    event1.WaitOne();
    Console.WriteLine("DoWork2はシグナルを受け取りました。");
    event1.Reset();
    Console.WriteLine("DoWork2は非シグナル状態にしました。");
    Thread.Sleep(1000);
    Console.WriteLine("DoWork2はシグナルを送りました。");
    event1.Set();
  }
  
  public static void DoWork3()
  {
    Thread.Sleep(1000);
    Console.WriteLine("DoWork3はシグナルを送りました。");
    event1.Set();
    Console.WriteLine("DoWork3はシグナル待ちです。");
    event1.WaitOne();
    Console.WriteLine("DoWork3はシグナルを受け取りました。");
  }
}

[Top] [SubIndex]


並列処理クラスを使うには (CLR 4.0 以上)

Parallel クラスを使うと、簡単にタスクを並列に実行できます。

using System;
using System.Threading.Tasks;

class ParallelFor
{
  static void Main()
  {
    // 従来の方法
    for (int i = 1; i <= 5 ; i++)
      Console.Write("{0} ", i);
    Console.WriteLine();
    
    // Parallel.For の使用例
    Parallel.For(1, 6, (n) => Console.Write("{0} ", n));  // 表示順が値の順にならない。
    Console.WriteLine();
    
    // Parallel.ForEach の使用例
    var a = new int[] { 1, 2, 3, 4, 5 };
    Parallel.ForEach(a, (n) => Console.Write("{0} ", n));  // 表示順が値の順にならない。
    Console.WriteLine();
  }
}

[Top] [SubIndex]


Task を使って並列処理を行うには (CLR 4.5 以上)

Task クラスを使うと、スレッドを簡単に利用できる。

using System;
using System.Threading.Tasks;

class TaskTest
{
  static void Main(string[] args)
  {
     Task[] tasks = new Task[3];
     tasks[0] = Task.Run(() => Console.WriteLine("task0"));  // タスク0開始 (Run メソッド使用)
     tasks[1] = new Task(() => Console.WriteLine("task1"));
     tasks[2] = new Task(() => Console.WriteLine("task2"));
     
     tasks[1].Start();  // タスク1開始
     tasks[2].Start();  // タスク2開始
     
     Task.WaitAll(tasks);  // すべてのタスクが終わるまで待機
  }
}

[Top] [SubIndex]


async, await を使うには (CLR 4.5 以上)

async, await キーワードを使うと、非同期タスクを同期動作のように記述できる。

using System;
using System.IO;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

class AsyncTest
{
  static void Main(string[] args)
  {
     if (args.Length == 0)
     {
        Console.WriteLine("ファイルを指定してください。");
        return;
     }
     
     var event1 = new ManualResetEvent(false);
     ReadAll(args[0], event1);  // このメソッドは並列に実行される。
     event1.WaitOne();  // メソッドの処理が終わるまで待つ。
  }
  
  // 非同期メソッド
  static async void ReadAll(string path, ManualResetEvent event1)
  {
     string str;
     using (var reader = new StreamReader(path, Encoding.Default))
     {
        str = await reader.ReadToEndAsync();  // 非同期でファイルをすべて読み込む。
     }
     Console.WriteLine(str);
     event1.Set();
  }
}

[Top] [SubIndex]


タイマーを使うには

タイマーは、System.Threading にもあるが、下の例は System.Timers の使用例である。

using System;
using System.Threading;

public class TimerTest
{
    public static void Main()
    {
       var count = 0;
       var timer1 = new System.Timers.Timer();
       var event1 = new ManualResetEventSlim();
       
        event1.Reset();
        timer1.Interval = 300;
        timer1.Elapsed +=
            (object source, System.Timers.ElapsedEventArgs e) => {
                count += 1;
                Console.WriteLine(count);
                if (count > 10)
                    event1.Set();
            };
        timer1.Start();
        event1.Wait();
        Console.WriteLine("Done.");
    }
}

[Top] [SubIndex]

 

 ネットワーク

TCP クライアント

単純な TCP クライアント

using System;
using System.Net.Sockets;
using System.Text;

public class TcpClient
{
  private const int portNum = 13;
  private const string hostName = "192.168.1.100";
  
  public static void Main(String[] args)
  {
    try
    {
      TcpClient client = new TcpClient(hostName, portNum);  // TcpClient をインスタンス化
      NetworkStream ns = client.GetStream();  // ストリームを得る。
      byte[] bytes = new byte[1024];  // バッファ
      int bytesRead = ns.Read(bytes, 0, bytes.Length);  // バッファにストリームからバイト列を取得する。
      Console.WriteLine(Encoding.ASCII.GetString(bytes, 0, bytesRead));
      client.Close();
    }
    catch (Exception e)
    {
      Console.WriteLine(e.ToString());
    }
  }
}

単純な HTTP クライアント

using System;
using System.Net;
using System.Net.Sockets;
using System.Text;

// 単純なHTTPクライアント
public class HttpClient : TcpClient
{
  private NetworkStream ns;
  private byte[] buffer = new byte[20000];
  
  // コンストラクタ(1)
  public HttpClient(string host) : base(host, 80)
  {
  }
  
  // コンストラクタ(2)
  public HttpClient(string host, int port) : base(host, port)
  {
  }
  
  // テキストをサーバへ送る
  protected void SendText(string text)
  {
    byte[] byteArray = Encoding.ASCII.GetBytes(text);
    this.ns.Write(byteArray, 0, byteArray.Length);
  }
  
  // テキストをサーバから受信する
  protected string ReceiveText()
  {
    int len = this.ns.Read(buffer, 0, buffer.Length);
    string str = Encoding.ASCII.GetString(buffer, 0, len);
    return str;
  }
  
  // GETコマンドを実行する
  public string Get(string pathname)
  {
    ns = this.GetStream();
    
    // GETコマンドを構築
    StringBuilder cmd = new StringBuilder();
    cmd.Append("GET " + pathname + " HTTP/1.1\n");
    cmd.Append("Host: ");
    cmd.Append(Dns.GetHostName());
    cmd.Append("\n");
    cmd.Append("\n");
    
    // GETコマンドを送る
    SendText(cmd.ToString());
    
    // GETコマンドを受信する
    string result = ReceiveText();
    ns.Close();
    return result;
  }
}

[Top] [SubIndex]


TCP リスナ

1つのクライアントからリクエストを受け付ける

using System;
using System.Collections.Generic;
using System.Text;
using System.Net;
using System.Net.Sockets;

namespace TcpListenerTest
{
    class Program
    {
        static void Main(string[] args)
        {
            TcpServer server = new TcpServer(11);
            Console.WriteLine("Listening ...");
            server.Listen();
            Console.WriteLine("closed.");
        }
    }
    
    class TcpServer
    {
        public int? port1 = null;
        private TcpListener tcpListener1 = null;
        private IPAddress address1 = null;
        private byte[] buffer = null;
        
        public TcpServer(int port)
        {
            this.buffer = new byte[4096];
            this.port1 = port;
            this.address1 = new IPAddress(new byte[] {127,0,0,1});
            this.tcpListener1 = new TcpListener(this.address1, (int)this.port1);
        }
        
        public void Listen()
        {
            this.tcpListener1.Start();
            TcpClient client = tcpListener1.AcceptTcpClient();    // blocking
            NetworkStream stream = client.GetStream();
            int n = stream.Read(buffer, 0, buffer.Length);
            string data = Encoding.ASCII.GetString(buffer, 0, n);
            Console.WriteLine(data);
            byte[] answer = new byte[] { 0x24, 0x0a };
            stream.Write(answer, 0, answer.Length);
            stream.Close();
        }
    }
}

スレッドを使って複数のクライアントを受け入れ可能にする

using System;
using System.Collections.Generic;
using System.Text;
using System.Net;
using System.Net.Sockets;
using System.Threading;

namespace TcpListenerTest2
{
    class Program
    {
        static void Main(string[] args)
        {
            TcpServer server = new TcpServer(11);
            Console.WriteLine("Listening ...");
            server.Listen();
            Console.WriteLine("Closed.");
        }
    }
    
    class TcpServer
    {
        public int? port1 = null;
        private TcpListener tcpListener1 = null;
        private IPAddress address1 = null;
        private bool flag = false;
        
        public TcpServer(int port)
        {
            this.port1 = port;
            this.address1 = new IPAddress(new byte[] { 127, 0, 0, 1 });
            this.tcpListener1 = new TcpListener(this.address1, (int)this.port1);
        }
        
        public void Listen()
        {
            this.tcpListener1.Start();
            
            while (true)
            {
                TcpClient client = tcpListener1.AcceptTcpClient();    // blocking
                if (flag) { break; }
                Thread thread = new Thread(DoWork);
                thread.Start(client);
                Console.WriteLine("accept");
            }
        }
        
        private void DoWork(object client)
        {
            byte[] buffer = new byte[4096];
            NetworkStream stream = ((TcpClient)client).GetStream();
            int n = stream.Read(buffer, 0, buffer.Length);
            string data = Encoding.ASCII.GetString(buffer, 0, n);
            Console.WriteLine(data);
            byte[] answer = new byte[] { 0x24, 0x0a };
            stream.Write(answer, 0, answer.Length);
            if (data.ToUpper() == "QUIT\r")
            {
                this.flag = true;
            }
            stream.Close();
        }
    }
}

[Top] [SubIndex]


UDP

サンプル1

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Net;

namespace UdpClientTest
{
    class Program
    {
        /// <summary>
        /// メイン
        /// </summary>
        /// <param name="args"></param>
        static void Main(string[] args)
        {
            if (args.Length == 0)
            {
                Console.WriteLine(@"Usage: UdpClinentTest.exe -s|-r|-S|-R host port
-s 同期送信
-r 同期受信
-S 非同期送信
-R 非同期受信
hostはIPアドレス
portはポート番号
");
#if DEBUG
                Console.ReadKey();
#endif
                System.Environment.Exit(9);
}

            try
            {
                IPAddress addr = IPAddress.Parse(args[1]);
                IPEndPoint ep = new IPEndPoint(addr, Int32.Parse(args[2]));
                
                if (args[0] == "-s")       // 同期送信
                {
                    TestSender(ep);
                    Console.WriteLine("同期送信 完了");
                    
                }
                else if (args[0] == "-r")  // 同期受信
                {
                    Console.WriteLine("同期受信 待機中 ...");
                    byte[] data = TestReceiver(ep);
                    foreach (byte x in data)
                    {
                        Console.Write("{0:x} ", x);
                    }
                    Console.WriteLine("\n同期受信 完了");
                }
                else if (args[0] == "-S")  // 非同期送信
                {
                    TestSender(ep, true);
                    Console.WriteLine("非同期送信 完了");
                }
                else if (args[0] == "-R")  // 非同期受信
                {
                    Console.WriteLine("非同期受信 待機中 ...");
                    TestReceiver(ep, true);
                    Console.WriteLine("非同期受信 完了");
                }
                else
                {
                    Console.WriteLine("Bad switch.");
                }
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
            }
            
#if DEBUG
            Console.ReadKey();
#endif
        }
        
        /// <summary>
        /// 送信のテスト
        /// </summary>
        /// <param name="ep"></param>
        static void TestSender(IPEndPoint ep, bool async = false)
        {
            var sender = new UdpSender();
            byte[] data = new byte[4] { 0x41,0x42, 0x53, 0x55 };
            
            if (async)
            {
                sender.SendAsync2(data, 4, (int n)=>{
                    Console.WriteLine("送信バイト数={0}", n);
                }, ep);
                sender.Wait();
            }
            else
            {
                sender.SendSync(data, 4, ep);
            }
        }
        
        /// <summary>
        /// 受信のテスト
        /// </summary>
        /// <param name="ep"></param>
        static byte[] TestReceiver(IPEndPoint ep, bool async = false)
        {
            var receiver = new UdpReceiver(ep);
            byte[] data = new byte[1];  // 非同期の場合ダミーとして返される。
            
            if (async)
            {
                receiver.ReceiveAsync2((byte[] buffer, IPEndPoint endPoint) => {
                    foreach (byte x in buffer)
                    {
                        Console.Write("{0:x} ", x);
                    }
                    Console.WriteLine("\n{0}", endPoint.ToString());
                });
                receiver.Wait();
            }
            else
            {
                data = receiver.ReceiveSync(ref ep);
            }
            return data;
        }
}
}

サンプル2

送り側

using System;
using System.Net;
using System.Net.Sockets;
using System.Threading;

namespace UdpClientTest
{
    public delegate void SenderCallback(int sentBytes);
    
    public class UdpSender : UdpClient
    {
        public ManualResetEvent manualEvent;
        
        /// <summary>
        /// コンストラクタ
        /// </summary>
        /// <param name="ep"></param>
        public UdpSender()
            : base()
        {
            manualEvent = new ManualResetEvent(false);
        }
        
        /// <summary>
        /// パケットを送信する。
        /// </summary>
        /// <param name="buffer"></param>
        /// <param name="bytes"></param>
        public void SendSync(byte[] buffer, int bytes, IPEndPoint dest)
        {
            this.Send(buffer, bytes, dest);
        }
        
        /// <summary>
        /// 非同期でパケットを送信する。
        /// </summary>
        /// <param name="callback"></param>
        public void SendAsync2(byte[] buffer, int bytes, SenderCallback callback, IPEndPoint dest)
        {
            BeginSend(buffer, bytes, dest,
                (IAsyncResult ar) =>
                {
                    int n = EndSend(ar);
                    callback(n);
                    manualEvent.Set();
                },
                this
            );
        }
        
        /// <summary>
        /// 動作完了イベント待受
        /// </summary>
        public void Wait()
        {
            manualEvent.WaitOne();
        }
    }
}

受け側

using System;
using System.Net;
using System.Net.Sockets;
using System.Threading;


namespace UdpClientTest
{
    public delegate void ReceiverCallback(byte[] buffer, IPEndPoint ep);
    
    public class UdpReceiver : UdpClient
    {
        public ManualResetEvent manualEvent;
        
        /// <summary>
        /// コンストラクタ
        /// </summary>
        /// <param name="ep"></param>
        public UdpReceiver(IPEndPoint ep)
            : base(ep)
        {
            manualEvent = new ManualResetEvent(false);
        }
        
        /// <summary>
        /// パケットを受信する
        /// </summary>
        /// <returns></returns>
        public byte[] ReceiveSync(ref IPEndPoint ep)
        {
            byte[] buffer = this.Receive(ref ep);
            return buffer;
        }
        
        /// <summary>
        /// パケットを非同期で受信する。
        /// </summary>
        public void ReceiveAsync2(ReceiverCallback callback)
        {
            BeginReceive(
                (IAsyncResult ar) =>
                {
                    IPEndPoint ep = null;
                    byte[] buffer = EndReceive(ar, ref ep);
                    callback(buffer, ep);
                    manualEvent.Set();
                },
                this
            );
        }
        
        /// <summary>
        /// 動作完了イベント待受
        /// </summary>
        public void Wait()
        {
            manualEvent.WaitOne();
        }
    }
}

[Top] [SubIndex]


HTTP クライアント

using System.Net.Http;
using System.Text;
using System.IO;
using System.Threading.Tasks;

namespace HttpClient
{
    public delegate void ReceiveFromHttp(string text);  // コールバック
    
    /// <summary>
    /// HTTPクライアント
    /// </summary>
    public class HttpClientClass
    {
        System.Net.Http.HttpClient client;
        
        /// <summary>
        /// コンストラクタ
        /// </summary>
        public HttpClientClass()
        {
            client = new System.Net.Http.HttpClient();
        }
        
        /// <summary>
        /// GETメソッド
        /// </summary>
        /// <param name="url"></param>
        /// <returns></returns>
        public async Task Get(string url, ReceiveFromHttp callback)
        {
            var response = await client.GetAsync(url);
            response.EnsureSuccessStatusCode();
            string responseBody = await response.Content.ReadAsStringAsync();
            callback(responseBody);
        }
        
        /// <summary>
        /// POSTメソッド
        /// </summary>
        /// <param name="url"></param>
        /// <param name="formText"></param>
        /// <returns></returns>
        public async Task Post(string url, string formText, ReceiveFromHttp callback)
        {
            var stream = new MemoryStream(Encoding.Default.GetBytes(formText));
            var content = new StreamContent(stream);
            var response = await client.PostAsync(url, content);
            response.EnsureSuccessStatusCode();
            string responseBody = await response.Content.ReadAsStringAsync();
            callback(responseBody);
        }
    }
}


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace HttpClient
{
    class Program
    {
        static void Main(string[] args)
        {
            string url = "http://localhost/doc/index.html";
            var client = new HttpClientClass();
            Task task = client.Get(url, Receive);
            task.Wait();
#if DEBUG
            Console.WriteLine("Done.");
            Console.ReadKey();
#endif
        }
        
        static void Receive(string text)
        {
            Console.WriteLine(text);
        }
}
}

[Top] [SubIndex]


HTTP サーバ

using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using System.Net;
using System.Threading;

namespace HttpServer
{
    public delegate void NotifyStatus(string msg);  // 状態通知用デリゲート
    
    /// <summary>
    /// HTTPリスナ
    /// </summary>
    public class HttpListenerClass
    {
        public event NotifyStatus OnNotify = null;   // 状態通知イベント
        private HttpListener listener;  // リスナオブジェクト
        private Thread thread;      // 要求待ちループスレッド
        private IAsyncResult result = null;    // 非同期オブジェクト
        private bool stopFlag = false;  // 停止要求フラグ
        private static object syncObject = new object();  // クリティカルセクション用
        private int requestNo = 0;   // 要求の数
        private Dictionary<string, string> routeMap;  // リクエスト対処理ルーチンのマ ップ
        
        /// <summary>
        /// コンストラクタ
        /// </summary>
        /// <param name="prefixes">待ち受けるクライアント一覧
        /// (例) http://localhost:8080
        ///      http://192.168.1.100:8080/Test
        /// </param>
        public HttpListenerClass(string[] prefixes, Dictionary<string, string> routeMap)
        {
            listener = new HttpListener();
            foreach (string s in prefixes)
            {
                listener.Prefixes.Add(s);
            }
            this.routeMap = routeMap;
        }
        
        /// <summary>
        /// リクエスト待ちループを開始する。
        /// </summary>
        public virtual void Start()
        {
            thread = new Thread(new ThreadStart(Loop));
            thread.Start();
        }
        
        /// <summary>
        /// リクエスト待ちループを終了する。
        /// </summary>
        public virtual void Stop()
        {
            if (this.result != null)
            {
                this.result.AsyncWaitHandle.Close();
                this.result = null;
                stopFlag = true;
                this.thread.Abort();
            }
        }
        
        /// <summary>
        /// リクエスト待ちループ
        /// </summary>
        public virtual void Loop()
        {
            this.listener.Start();
            while (true)
            {
                this.result = listener.BeginGetContext(new AsyncCallback(Work), listener);
                this.result.AsyncWaitHandle.WaitOne();
                if (this.stopFlag)
                {
                    break;
                }
                requestNo += 1;
            }
            listener.Close();
            this.result = null;
        }
        
        /// <summary>
        /// リクエストを処理する。
        /// </summary>
        /// <param name="result"></param>
        public virtual void Work(object result)
        {
            HttpListener listner2 = ((IAsyncResult)result).AsyncState as HttpListener;   
            if (listner2 == null)
            {
                return;
            }
            
            if (!listner2.IsListening)
            {
                return;
            }
            
            // 要求を処理する
            HttpListenerContext context = listner2.EndGetContext((IAsyncResult)result);
            HttpListenerRequest request = context.Request;
            HttpListenerResponse response = context.Response;
            //string responseString = "<HTML><BODY> <h2>Hello world!</h2> </BODY></HTML>";
            string responseString = GetResponseString(request);
            byte[] buffer = System.Text.Encoding.UTF8.GetBytes(responseString);
            response.ContentLength64 = buffer.Length;
            Stream output = response.OutputStream;
            output.Write(buffer, 0, buffer.Length);
            output.Close();
        }
        
        /// <summary>
        /// 応答文字列を返す。
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public virtual string GetResponseString(HttpListenerRequest request)
        {
            HtmlDocClass doc = new HtmlDocClass(routeMap);
            return doc.GetDocument(request);
        }
    }
}


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace HttpServer
{
    class Program
    {
        static void Main(string[] args)
        {
            string[] prefixes = new string[] {
                "http://localhost:8080/",
            };
            Dictionary<string, string> routeMap = new Dictionary<string, string>();
            routeMap.Add("/", "DocRoot");
            routeMap.Add("/Priv", "Private");
            HttpListenerClass httpServer = new HttpListenerClass(prefixes, routeMap);
            httpServer.Start();
            Console.WriteLine("Http Server Started.");
        }
    }
}

[Top] [SubIndex]

 

 リフレクション

クラスのメンバーを列挙するには

あるクラスの含まれるメソッドやプロパティを列挙するには、Type クラスを使用する。

using System;
using System.Reflection;

namespace QueryMember
{
    class Program
    {
        static void Main(string[] args)
        {
            if (args.Length <= 1)
            {
                Console.WriteLine("QueryMember type member   (memberはワイルドカードが使用できる。)");
                goto End;
            }
            
            var t = Type.GetType(args[0]);
            MemberInfo[] members = t.GetMember(args[1],
                MemberTypes.Method,
                BindingFlags.Public | BindingFlags.Instance |
                BindingFlags.DeclaredOnly | BindingFlags.IgnoreCase);
            foreach (MemberInfo m in members)
            {
                //メンバの名前を表示する
                Console.WriteLine(m.Name);
            }
            
            Console.WriteLine("\n** FindMethod");
            var methods = FindMethods("System.String", "ToLower");
            if (methods != null)
            {
                foreach (MemberInfo i in methods)
                {
                    Console.WriteLine("{0:g}", i);
                }
            }
            
            Console.WriteLine("\n** FindProperties");
            var properties = FindProperties("System.String", "Length");
            if (properties != null)
            {
                foreach (MemberInfo i in properties)
                {
                    Console.WriteLine("{0:g}", i);
                }
            }
            
            Console.WriteLine("\n** FindFields");
            var fields = FindFields("System.Type", "Missing");
            if (fields != null)
            {
                foreach (MemberInfo i in fields)
                {
                    Console.WriteLine("{0:g}", i);
                }
            }
            
            Console.WriteLine("\n** FindEvents");
            var events = FindEvents("System.Timers.Timer", "Elapsed");
            if (events != null)
            {
                foreach (MemberInfo i in events)
                {
                    Console.WriteLine("{0:g}", i);
                }
            }
            
        End: ;
#if DEBUG
            Console.WriteLine("\nDone.");
            Console.ReadKey();
#endif
        }
        
        /// <summary>
        /// アセンブリ内のメソッドを検索する。
        /// </summary>
        /// <param name="cls">クラス名</param>
        /// <param name="name">メソッド名</param>
        /// <returns>見つかったMethodInfo</returns>
        public static MethodInfo[] FindMethods(string cls, string name)
        {
            MethodInfo[] info = null;
            var t = Type.GetType(cls);
            if (t == null)
                return null;
            var bindings = BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static;
            info = (MethodInfo[])t.GetMember(name, MemberTypes.Method, bindings);
            return info;
        }
        
        /// <summary>
        /// アセンブリ内のプロパティを検索する。
        /// </summary>
        /// <param name="cls">クラス名</param>
        /// <param name="name">プロパティ名</param>
        /// <returns>見つかったPropertyInfo</returns>
        public static PropertyInfo[] FindProperties(string cls, string name)
        {
            PropertyInfo[] info = null;
            var t = Type.GetType(cls);
            if (t == null)
                return null;
            var bindings = BindingFlags.Public | BindingFlags.Instance;
            info = (PropertyInfo[])t.GetMember(name, MemberTypes.Property, bindings);
            return info;
        }
        
        /// <summary>
        /// アセンブリ内のフィールドを検索する。
        /// </summary>
        /// <param name="cls">クラス名</param>
        /// <param name="name">プロパティ名</param>
        /// <returns>見つかったFieldInfo</returns>
        public static FieldInfo[] FindFields(string cls, string name)
        {
            FieldInfo[] info = null;
            var t = Type.GetType(cls);
            if (t == null)
                return null;
            var bindings = BindingFlags.Public | BindingFlags.Static;
            info = (FieldInfo[])t.GetMember(name, MemberTypes.Field, bindings);
            return info;
        }
        
        /// <summary>
        /// アセンブリ内のイベントを検索する。
        /// </summary>
        /// <param name="cls">クラス名</param>
        /// <param name="name">プロパティ名</param>
        /// <returns>見つかったEventInfo</returns>
        public static EventInfo[] FindEvents(string cls, string name)
        {
            EventInfo[] info = null;
            var t = Type.GetType(cls); // typeof (System.Timers.Timer);
            if (t == null)
                return null;
            var bindings = BindingFlags.Public | BindingFlags.Instance;
            info = (EventInfo[])t.GetMember(name, MemberTypes.Event, bindings);
            return info;
        }
}
}

[Top] [SubIndex]


リフレクションを使ってメソッドを呼び出すには

リフレクションを使ってメソッドを呼び出すには Type クラスの InvokeMember メソッドを使用する。

using System;
using System.Text;
using System.Reflection;

class Program
{
     static void Main(string[] args)
     {
         try
         {
             // インスタンスの作成
             var t1 = typeof(System.Text.StringBuilder);
             var sb = (StringBuilder)t1.InvokeMember(null, BindingFlags.CreateInstance, null, null, null);
             
             // インスタンスメソッドの使用
             t1.InvokeMember("Append", BindingFlags.InvokeMethod, null, sb, new object[] { "ABCD" });
             t1.InvokeMember("Append", BindingFlags.InvokeMethod, null, sb, new object[] { "0123" });
             var str = (String)t1.InvokeMember("ToString", BindingFlags.InvokeMethod, null, sb, new object[] { });
             Console.WriteLine(str);
             
             // プロパティの取得
             var n = (int)t1.InvokeMember("Length", BindingFlags.GetProperty, null, sb, null);
             Console.WriteLine(n.ToString());
             // あるいは
             var propInfo = t1.GetProperty("Length"); 
             n = (int)propInfo.GetValue(sb);
             Console.WriteLine(n.ToString());
             
             // Staticメソッドの使用
             var t2 = typeof(Math);
             Console.WriteLine(t2.FullName);
             var x = (double)t2.InvokeMember("Log", BindingFlags.InvokeMethod, null, null, new object[1] { 3.0 });
             Console.WriteLine("{0:#.####}", x);
             
             // 可変パラメータの場合
             var t3 = typeof(String);
             Console.WriteLine(t3.FullName);
             var arg = new object[2];
             arg[0] = "x={g}, y ={g}\n";
             arg[1] = new object[2] {1.5, 4.4};
             t1 = typeof(System.IO.StreamReader);
             var fs = (System.IO.StreamReader)t1.InvokeMember(null, BindingFlags.CreateInstance, null, null, new object[2] { @"C:\workspace\project2012\nbasic\test\Method.bas",  System.Text.Encoding.Default });
             string s  = (string)t1.InvokeMember("ReadLine", BindingFlags.InvokeMethod, null, fs, null);
             Console.WriteLine(s);
             t1.InvokeMember("Close", BindingFlags.InvokeMethod, null, fs, null);
         }
         catch (Exception ex)
         {
             Console.WriteLine(ex.Message);
             Console.WriteLine(ex.StackTrace);
         }
         finally
         {
#if DEBUG
             Console.ReadKey();
#endif
         }
}
 }

[Top] [SubIndex]


アセンブリに含まれる情報を得るには

using System;
using System.Reflection;
using System.Security.Permissions;

public class Test
{
  [PermissionSetAttribute(SecurityAction.Demand, Name="FullTrust")]
  public static void Main()
  {
    Console.WriteLine("System.Reflection Test");
    
    try
    {
      Assembly assy = Assembly.LoadFile(@"D:\workspace\\File\FileTest.exe");
      Console.WriteLine(assy.CodeBase);
      Console.WriteLine(assy.FullName);
      Console.WriteLine(assy.Location);
      Console.WriteLine(assy.ManifestModule.FullyQualifiedName);
      Console.WriteLine(assy.GetName().Version.ToString());
      Type[] ts = assy.GetTypes();
      foreach (Type t in ts)
      {
        Console.WriteLine(t.ToString());
      }
    }
    catch (Exception ex)
    {
      Console.WriteLine(ex.Message);
    }
  }
}

[Top] [SubIndex]


アセンブリに含まれるクラスのメソッドを呼び出すには

using System;
using System.Reflection;

namespace ReflectionTest
{
  class ReflectionTest
  {
    public static void Main(string[] args)
    {
       // 通常のやり方
       Class1 o = new Class1();
       o.Money(100);
       o.Percent(0.5);
       
       // リフレクションを使うやり方
       Assembly asm = Assembly.LoadFrom("Class1.dll");
       Type pt = asm.GetType("ReflectionTest.Class1");
       Class1 p =(Class1)Activator.CreateInstance(pt);
       p.Money(1000);
       p.Percent(0.1);
    }
  }
}

[Top] [SubIndex]

 

 OS とシェル

ショートカットのパスを取得するには

下に WSH ライブラリを使ったショートカットのターゲットパスを表示する例を示す。よって、ビルド時、リンクに Interop.IWshRuntimeLibrary.dll を含める必要がある。リフレクションを使う方などもある。

using System;
using System.IO;
using IWshRuntimeLibrary;

//
//  ビルド時、リンクに Interop.IWshRuntimeLibrary.dll を含めること。
//
public class ShortcutTest
{
  public static void Main(string[] args)
  {
     if (args.Length == 0)
     {
        Console.WriteLine("ショートカットを指定してください。その際、拡張子 .lnk を付けてください。");
        return;
     }
     
     WshShell shell = new WshShell();
     IWshShortcut link = (IWshShortcut)shell.CreateShortcut(args[0]);
     Console.WriteLine(link.TargetPath);  // ショートカットのターゲットパスを表示
  }
}

[Top] [SubIndex]


ショートカットを作るには

using System;
using System.IO;
using IWshRuntimeLibrary;

//
//  ビルド時、リンクに Interop.IWshRuntimeLibrary.dll を含めること。
//
public class ShortcutTest
{
  public static void Main(string[] args)
  {
     if (args.Length != 2)
     {
        Console.WriteLine("ショートカットとターゲットパスを指定してください。ショートカットには拡張子 .lnk を付けてください。");
        return;
     }
     
     WshShell shell = new WshShell();
     IWshShortcut link = (IWshShortcut)shell.CreateShortcut(args[0]);
     link.TargetPath = args[1];
     link.Save();
     Console.WriteLine("ショートカットを作成しました。");
  }
}

[Top] [SubIndex]


OS のバージョンを取得するには

using System;

public class OSVersion
{
  public static void Main(string[] args)
  {
     Console.WriteLine(System.Environment.OSVersion);
  }
}

表示例

Microsoft Windows NT 6.1.7601 Service Pack 1

[Top] [SubIndex]

 

 XML

XML ファイルを読むには (XmlDocument)

このサンプルは XmlDocument クラスを継承した UrlData というクラスを作って XML ファイルを読む例である。

using System;
using System.Xml;
using System.IO;
using System.Text;
using System.Collections;


namespace Test
{
public class TestXmlDocument
{
  public static int Main(String[] args)
  {
    if (args.Length == 0)
    {
      Console.WriteLine("Usage: TestXmlDocument ");
      return -1;
    }
    
    UrlData url = new UrlData();
    
    try
    {
      url.LoadXml(args[0]);
      
      Console.WriteLine("Protocol = " + url.Protocol);
      Console.WriteLine("Host = " + url.Host);
      Console.WriteLine("Port = " + url.Port);
      Console.WriteLine("PathName = " + url.PathName);
    }
    catch (Exception ex)
    {
      Console.WriteLine(ex.Message);
    }
    
    return 0;
  }
}

//
//  URLデータを読む
//  ===============
public class UrlData : XmlDocument
{
  private ArrayList nodes = new ArrayList();
  
  public UrlData() : base()
  {
  }
  
  public override void LoadXml(string filename)
  {
    TextFileReader textFile = new TextFileReader(filename);
    string XmlString = textFile.ToString();
    base.LoadXml(XmlString);
    XmlNode current = FirstChild;    // 
    current = current.NextSibling;    //  .. 
    current = current.FirstChild;    //    .. 
    nodes.Add(current.InnerText);
    current = current.NextSibling;    //    .. 
    nodes.Add(current.InnerText);
    current = current.NextSibling;    //    .. 
    nodes.Add(current.InnerText);
    current = current.NextSibling;    //    .. 
    nodes.Add(current.InnerText);
  }
  
  public string Protocol
  {
    get
    {
      return (string)nodes[0];
    }
  }
  
  public string Host
  {
    get
    {
      return (string)nodes[1];
    }
  }
  
  public string Port
  {
    get
    {
      return (string)nodes[2];
    }
  }
  
  public string PathName
  {
    get
    {
      return (string)nodes[3];
    }
  }
}

//
//  指定したテキストファイルを読む
//  ===============================
public class TextFileReader
{
  private StreamReader fs;
  public ArrayList lines = new ArrayList();
  
  //
  //  コンストラクタ
  //  
  public TextFileReader(string filename)
  {
    string s;
    
    using (fs = File.OpenText(filename))
    {
      while ((s = fs.ReadLine()) != null)
      {
        lines.Add(s);
      }
      fs.Close();
    }
  }
  
  //
  //  文字列に変換する
  //
  public override string ToString()
  {
    StringBuilder sb = new StringBuilder();
    
    foreach (string s in lines)
    {
      sb.Append(s);
    }
    
    return sb.ToString();
  }
}
}

下のサンプルは最初のサンプルを改良したものである。

using System;
using System.Xml;
using System.IO;
using System.Text;
using System.Collections.Generic;

/**************************************************************

     複数項目を読めるように変更
     要素の名前を確認
     属性も取得できるように変更
     
**************************************************************/
namespace Test
{
public class TestXmlDocument4
{
  public static int Main(String[] args)
  {
    if (args.Length == 0)
    {
      Console.WriteLine("Usage: TestXmlDocument4 ");
      return -1;
    }
    
    UrlData url = new UrlData();
    
    try
    {
      url.Load(args[0]);
      
      for (int i = 0; i < url.Count; i++)
      {
        Console.WriteLine("URL: " + (i + 1));
        Console.WriteLine("favicon = " + url.Item(i).favicon);
        Console.WriteLine("robots = " + url.Item(i).robots);
        Console.WriteLine("Protocol = " + url.Item(i).Protocol);
        Console.WriteLine("Host = " + url.Item(i).Host);
        Console.WriteLine("Port = " + url.Item(i).Port);
        Console.WriteLine("PathName = " + url.Item(i).PathName);
      }
    }
    catch (Exception ex)
    {
      Console.WriteLine(ex.Message);
    }
    
    return 0;
  }
}

public struct UrlItem
{
  public bool favicon;
  public bool robots;
  public string Protocol;
  public string Host;
  public string Port;
  public string PathName;
}

//
//  URLデータを読む
//  ===============
public class UrlData : XmlDocument
{
  public List nodes = new List();
  
  public UrlData() : base()
  {
  }
  
  public override void Load(string filename)
  {
    base.Load(filename);
    PutUrlItems();
  }
  
  // XMLノードをListに格納
  private void PutUrlItems()
  {
    XmlNode current = FirstChild;    // 
    current = current.NextSibling;    //  .. 
    current = current.FirstChild;    //    .. 
    XmlElement element;
    while (current != null)
    {
      UrlItem item = new UrlItem();
      item.favicon = Boolean.Parse(current.Attributes["favicon"].InnerText);
      item.robots = Boolean.Parse(current.Attributes["robots"].InnerText);
      element = current["protocol"];    //    .. 
      item.Protocol = element.InnerText;
      element = current["host"];    //    .. 
      item.Host = element.InnerText;
      element = current["port"];    //    .. 
      item.Port = element.InnerText;
      element = current["pathname"];    //    .. 
      item.PathName = element.InnerText;
      nodes.Add(item);
      current = current.NextSibling;    //  .. 
    }
  }
  
  // n番目のurlを得る
  public UrlItem Item(int n)
  {
    return (UrlItem)nodes[n];
  }
  
  // urlノードの数を得る
  public int Count
  {
    get
    {
      return nodes.Count;
    }
  }
}

}

[Top] [SubIndex]


XmlSerializer を使ってオブジェクトをシリアライズするには

using System.Xml;
using System.Xml.Serialization;
using System.IO;

public class ClassA
{
  public int iA;
  public ClassB cB = new ClassB();
  public ClassB cC = new ClassB();
  
}

public class ClassB
{
  public int iB;
  public ClassC cD = new ClassC();
}

public class ClassC
{
  public int iC;
}

public class Test
{
  public static void Main()
  {
    ClassA a = new ClassA();
    saveTo("xxxx.xml", a);
  }
  
  public static void saveTo(string filename, ClassA a)
  {
    XmlSerializer ser = new XmlSerializer(typeof(ClassA));
    StreamWriter sw = new StreamWriter(filename);
    XmlTextWriter xw = new XmlTextWriter(sw);
    ser.Serialize(xw, a);
    sw.Close();
  }
}

[Top] [SubIndex]

 

 ログとデバッグ

TraceSource を使ってログを取る

using System;
using System.Windows.Forms;
using System.Diagnostics;
using System.IO;
using Resources = global::LoggerTest2.Properties.Resources;

namespace LoggerTest2
{
    public partial class Form1 : Form
    {
        Form2 form2;
        TraceSource logger = null;
        TextWriterTraceListener listener, listener2;
        MemoryStream stream = null;
        byte[] buffer = null;
        const int BufferSize = 2048;
        
        /// <summary>
        /// コンストラクタ
        /// </summary>
        public Form1()
        {
            InitializeComponent();
        }
        
        /// <summary>
        /// Formがロードした時
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void Form1_Load(object sender, EventArgs e)
        {
            comboBox1.SelectedIndex = 0;
            comboBox2.SelectedIndex = 0;
        }
        
        /// <summary>
        /// Add Log ボタン
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void button1_Click(object sender, EventArgs e)
        {
            if (logger == null)
            {
                SourceLevels sourceLevels = getSourceLevel();
                logger = new TraceSource("LoggerTest2", sourceLevels);
                comboBox1.Enabled = false;
                buffer = new byte[BufferSize];
                stream = new MemoryStream(buffer, 0, BufferSize);
                listener = new TextWriterTraceListener(stream, "LoggerTest2");
                listener2 = new TextWriterTraceListener(File.Open(Resources.LogFile, FileMode.Append));
                listener.TraceOutputOptions = getTraceOutputOptions();
                logger.Listeners.Add(listener);
                logger.Listeners.Add(listener2);
                checkedListBox1.Enabled = false;
                form2 = new Form2();
                form2.fireClosing += delegate(Form form) 
                {
                    form2 = null;
                };
                form2.Show();
            }
            
            var et = getTraceEventType();
            logger.TraceEvent(et, Int32.Parse(textBox2.Text), textBox1.Text);
            //logger.TraceInformation(textBox1.Text);
            listener.Flush();
            listener2.Flush();
            
            if (form2 != null)
            {
                form2.ShowLog(buffer);
                buffer.Clear(0, BufferSize);
                stream.Seek(0, SeekOrigin.Begin);
            }
        }
        
        /// <summary>
        /// comboBox1からSourceLevelsを得る。
        /// </summary>
        /// <returns></returns>
        private SourceLevels getSourceLevel()
        {
            SourceLevels[] src = {
                        SourceLevels.All,
                        SourceLevels.Off,
                        SourceLevels.Critical,
                        SourceLevels.Error,
                        SourceLevels.Warning,
                        SourceLevels.Verbose,
            };
            
            return src[comboBox1.SelectedIndex];
        }
        
        /// <summary>
        /// comboBox2からTraceEventTypeを得る。
        /// </summary>
        /// <returns></returns>
        private TraceEventType getTraceEventType()
        {
            TraceEventType[] types =  {
                        TraceEventType.Information,
                        TraceEventType.Warning,
                        TraceEventType.Error,
                        TraceEventType.Critical,
                        TraceEventType.Start,
                        TraceEventType.Stop,
                        TraceEventType.Suspend,
                        TraceEventType.Resume,
                        TraceEventType.Transfer,
            };
            
            var i = comboBox2.SelectedIndex;
            return types[i];
        }
        
        /// <summary>
        /// checkedListBox1からトレースオプションを得る。
        /// </summary>
        /// <returns></returns>
        private TraceOptions getTraceOutputOptions()
        {
            TraceOptions ret = 0;
            
            foreach (string x in checkedListBox1.SelectedItems)
            {
                switch (x)
                {
                    case "None":
                        ret |= TraceOptions.None;
                        break;
                        
                    case "LogicalOperationStack":
                        ret |= TraceOptions.LogicalOperationStack;
                        break;
                        
                    case "DateTime":
                        ret |= TraceOptions.DateTime;
                        break;
                        
                    case "Timestamp":
                        ret |= TraceOptions.Timestamp;
                        break;
                        
                    case "ProcessId":
                        ret |= TraceOptions.ProcessId;
                        break;
                        
                    case "ThreadId":
                        ret |= TraceOptions.ThreadId;
                        break;
                        
                    case "Callstack":
                        ret |= TraceOptions.Callstack;
                        break;
                }
            }
            
            return ret;
        }
        
        /// <summary>
        /// Closeボタン
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void button2_Click(object sender, EventArgs e)
        {
            Close();
        }
    }
}

[Top] [SubIndex]


 WMI

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Management;

namespace WmiTest
{
    public static class WMI
    {
        /// 
        /// プロセス情報
        /// 
        /// 
        /// 
        /// 
        public static string[] QueryProcesses()
        {
            var result = new List();
            var searcher = new ManagementObjectSearcher("SELECT * FROM Win32_Process");
            var coll = searcher.Get();
            var sb = new StringBuilder();
            
            foreach (ManagementObject item in coll)
            {
                sb.Append(toStr(item["Description"]) + "\t");
                sb.Append(toStr(item["ProcessId"]) + "\t");
                sb.Append(toStr(item["ParentProcessId"]) + "\t");
                sb.Append(toStr(item["VirtualSize"]) + "\t");
                sb.Append(toStr(item["PeakPageFileUsage"]) + "\t");
                sb.Append(toStr(item["Priority"]) + "\t");
                sb.Append(toStr(item["ThreadCount"]));
                
                result.Add(sb.ToString());
                sb = new StringBuilder();
            }
            
            return result.ToArray();
        }
        
        /// 
        /// OS情報
        /// 
        /// 
        /// 
        /// 
        public static string[] QueryOS()
        {
            var searcher = new ManagementObjectSearcher("SELECT * FROM Win32_OperatingSystem");
            var coll = searcher.Get();
            var result = new List();
            foreach (var item in coll)
            {
                result.Add(toStr(item["Caption"]));
                result.Add(toStr(item["Version"]));
                result.Add(toStr(item["SystemDrive"]));
                result.Add(toStr(item["WindowsDirectory"]));
                result.Add(toStr(item["SystemDirectory"]));
                result.Add(toStr(item["TotalVisibleMemorySize"]));
                result.Add(toStr(item["TotalVirtualMemorySize"]));
                result.Add(toStr(item["SystemDevice"]));
            }
            
            return result.ToArray();
        }
        
        
        /// 
        /// コンピュータシステム情報
        /// 
        /// 
        public static string[] QueryComputerSystem()
        {
            var searcher = new ManagementObjectSearcher("SELECT * FROM Win32_ComputerSystem");
            var coll = searcher.Get();
            var result = new List();
            foreach (var item in coll)
            {
                result.Add(toStr(item["Caption"]));
                result.Add(toStr(item["Description"]));
                result.Add(toStr(item["CurrentTimeZone"]));
                result.Add(toStr(item["DNSHostName"]));
                result.Add(toStr(item["Domain"]));
                result.Add(toStr(item["DomainRole"]));
                result.Add(toStr(item["InstallDate"]));
                result.Add(toStr(item["Manufacturer"]));
                result.Add(toStr(item["Model"]));
                result.Add(toStr(item["Name"]));
                result.Add(toStr(item["NumberOfLogicalProcessors"]));
                result.Add(toStr(item["NumberOfProcessors"]));
                result.Add(toStr(item["PartOfDomain"]));
                result.Add(toStr(item["PCSystemType"]));
                result.Add(toStr(item["PowerManagementSupported"]));
                result.Add(toStr(item["PowerState"]));
                result.Add(toStr(item["SystemType"]));
                result.Add(toStr(item["TotalPhysicalMemory"]));
                result.Add(toStr(item["UserName"]));
                result.Add(toStr(item["WakeUpType"]));
                result.Add(toStr(item["Workgroup"]));
            }
            
            return result.ToArray();
        }
        
        /// 
        /// プリンタ情報
        /// 
        /// 
        public static string[] QueryPrinter()
        {
            var searcher = new ManagementObjectSearcher("SELECT * FROM Win32_Printer");
            var coll = searcher.Get();
            var sb = new StringBuilder();
            var result = new List();
            foreach (var item in coll)
            {
                sb.Append(toStr(item["Caption"]) + "\t");
                sb.Append(toStr(item["Attributes"]) + "\t");
                sb.Append(toStr(item["DeviceID"]) + "\t");
                sb.Append(toStr(item["Network"]) + "\t");
                sb.Append(toStr(item["PortName"]) + "\t");
                sb.Append(toStr(item["PrinterStatus"]));
                result.Add(sb.ToString());
                sb = new StringBuilder();
            }
            
            return result.ToArray();
        }
        
        /// 
        /// ネットワークアダプタ情報
        /// 
        /// 
        public static string[] QueryNetworkAdapter()
        {
            var searcher = new ManagementObjectSearcher("SELECT * FROM Win32_NetworkAdapter");
            var coll = searcher.Get();
            var sb = new StringBuilder();
            var result = new List();
            foreach (var item in coll)
            {
                sb.Append(toStr(item["Caption"]) + "\t");
                sb.Append(toStr(item["DeviceID"]) + "\t");
                sb.Append(toStr(item["AdapterType"]) + "\t");
                sb.Append(toStr(item["Availability"]) + "\t");
                sb.Append(toStr(item["ConfigManagerErrorCode"]) + "\t");
                sb.Append(toStr(item["Installed"]) + "\t");
                sb.Append(toStr(item["LastErrorCode"]) + "\t");
                sb.Append(toStr(item["MACAddress"]) + "\t");
                sb.Append(toStr(item["Manufacturer"]) + "\t");
                sb.Append(toStr(item["MaxSpeed"]) + "\t");
                sb.Append(toStr(item["NetConnectionStatus"]) + "\t");
                sb.Append(toStr(item["NetEnabled"]) + "\t");
                sb.Append(toStr(item["PhysicalAdapter"]) + "\t");
                sb.Append(toStr(item["PNPDeviceID"]) + "\t");
                sb.Append(toStr(item["ProductName"]) + "\t");
                sb.Append(toStr(item["Speed"]) + "\t");
                sb.Append(toStr(item["StatusInfo"]));
                
                result.Add(sb.ToString());
                sb = new StringBuilder();
            }
            
            return result.ToArray();
        }
        
        /// 
        /// ネットワークアダプタ構成情報
        /// 
        /// 
        public static string[] QueryNetworkAdapterConfiguration()
        {
            var searcher = new ManagementObjectSearcher("SELECT * FROM Win32_NetworkAdapterConfiguration");
            var coll = searcher.Get();
            var sb = new StringBuilder();
            var result = new List();
            foreach (var item in coll)
            {
                sb.Append(toStr(item["Caption"]) + "\t");
                sb.Append(toStr(item["DHCPEnabled"]) + "\t");
                sb.Append(toStr(item["DHCPLeaseExpires"]) + "\t");
                sb.Append(toStr(item["DHCPLeaseObtained"]) + "\t");
                sb.Append(toStr(item["DHCPServer"]) + "\t");
                sb.Append(toStr(item["DNSDomain"]) + "\t");
                sb.Append(toStr(item["DNSHostName"]) + "\t");
                sb.Append(toStr(item["IPAddress"]) + "\t");
                sb.Append(toStr(item["IPEnabled"]) + "\t");
                sb.Append(toStr(item["KeepAliveTime"]) + "\t");
                sb.Append(toStr(item["ServiceName"]));
                
                result.Add(sb.ToString());
                sb = new StringBuilder();
            }
            
            return result.ToArray();
        }
        
        
        /// 
        /// サービス情報
        /// 
        /// 
        public static string[] QueryService()
        {
            var searcher = new ManagementObjectSearcher("SELECT * FROM Win32_Service");
            var coll = searcher.Get();
            var sb = new StringBuilder();
            var result = new List();
            foreach (var item in coll)
            {
                sb.Append(toStr(item["Caption"]) + "\t");
                sb.Append(toStr(item["Name"]) + "\t");
                sb.Append(toStr(item["PathName"]) + "\t");
                sb.Append(toStr(item["ProcessId"]) + "\t");
                sb.Append(toStr(item["ServiceType"]) + "\t");
                sb.Append(toStr(item["Started"]) + "\t");
                sb.Append(toStr(item["Status"]) + "\t");
                sb.Append(toStr(item["StartName"]));
                
                result.Add(sb.ToString());
                sb = new StringBuilder();
            }
            
            return result.ToArray();
        }
        
        /// 
        /// Windowsログ情報
        /// 
        /// 
        /// 実行には時間がかかる。1週間前からのエラーのみ。
        public static string[] QueryNTLog()
        {
            string date = String.Format("{0:yyyy/MM/dd}", DateTime.Now.AddDays(-7));
            var searcher = new ManagementObjectSearcher("SELECT * FROM Win32_NTLogEvent WHERE EventType = 1 AND TimeGenerated >= '" + date +"'");
            var coll = searcher.Get();
            var sb = new StringBuilder();
            var result = new List();
            foreach (var item in coll)
            {
                sb.Append(toStr(item["TimeGenerated"]) + "\t");
                sb.Append(toStr(item["Type"]) + "\t");
                sb.Append(toStr(item["User"]) + "\t");
                sb.Append(toStr(item["Message"]) + "\t");
                sb.Append(toStr(item["EventType"]) + "\t");
                sb.Append(toStr(item["EventCode"]));
                
                result.Add(sb.ToString());
                sb = new StringBuilder();
            }
            
            return result.ToArray();
        }
        
        /// 
        /// 論理ディスク情報
        /// 
        /// 
        public static string[] QueryLogicalDisk()
        {
            var searcher = new ManagementObjectSearcher("SELECT * FROM Win32_LogicalDisk");
            var coll = searcher.Get();
            var sb = new StringBuilder();
            var result = new List();
            foreach (var item in coll)
            {
                sb.Append(toStr(item["DeviceID"]) + "\t");
                sb.Append(toStr(item["Description"]) + "\t");
                sb.Append(toStr(item["DriveType"]) + "\t");
                sb.Append(toStr(item["ErrorDescription"]) + "\t");
                sb.Append(toStr(item["FileSystem"]) + "\t");
                sb.Append(toStr(item["FreeSpace"]) + "\t");
                sb.Append(toStr(item["LastErrorCode"]) + "\t");
                sb.Append(toStr(item["Size"]) + "\t");
                sb.Append(toStr(item["VolumeName"]));
                
                result.Add(sb.ToString());
                sb = new StringBuilder();
            }
            
            return result.ToArray();
        }
        
        /// 
        /// プロセッサ情報
        /// 
        /// 
        public static string[] QueryProcessor()
        {
            var searcher = new ManagementObjectSearcher("SELECT * FROM Win32_Processor");
            var coll = searcher.Get();
            var sb = new StringBuilder();
            var result = new List();
            foreach (var item in coll)
            {
                sb.Append(toStr(item["Caption"]) + "\t");
                sb.Append(toStr(item["CurrentClockSpeed"]) + "\t");
                sb.Append(toStr(item["CurrentVoltage"]) + "\t");
                sb.Append(toStr(item["DeviceID"]) + "\t");
                sb.Append(toStr(item["Family"]) + "\t");
                sb.Append(toStr(item["Manufacturer"]) + "\t");
                sb.Append(toStr(item["ProcessorId"]) + "\t");
                sb.Append(toStr(item["Revision"]) + "\t");
                sb.Append(toStr(item["Stepping"]) + "\t");
                sb.Append(toStr(item["Version"]));
                
                result.Add(sb.ToString());
                sb = new StringBuilder();
            }
            
            return result.ToArray();
        }
        
        /// 
        /// ユーザ情報
        /// 
        /// 
        public static string[] QueryUserAccount()
        {
            var searcher = new ManagementObjectSearcher("SELECT * FROM Win32_UserAccount");
            var coll = searcher.Get();
            var sb = new StringBuilder();
            var result = new List();
            foreach (var item in coll)
            {
                sb.Append(toStr(item["Caption"]) + "\t");
                sb.Append(toStr(item["Disabled"]) + "\t");
                sb.Append(toStr(item["Domain"]) + "\t");
                sb.Append(toStr(item["FullName"]) + "\t");
                sb.Append(toStr(item["PasswordChangeable"]) + "\t");
                sb.Append(toStr(item["PasswordExpires"]) + "\t");
                sb.Append(toStr(item["PasswordRequired"]) + "\t");
                sb.Append(toStr(item["Status"]));
                
                result.Add(sb.ToString());
                sb = new StringBuilder();
            }
            
            return result.ToArray();
        }
        
        /// 
        /// 文字列表現
        /// 
        /// 
        /// 
        public static string toStr(object x)
        {
            if (x == null)
            {
                return "(null)";
            }
            else
            {
                return x.ToString();
            }
        }
    }
}

[Top] [SubIndex]

 

 

このページのトップへ