2010-10-03T23:14:09の更新内容

programming/tips/msdos_cmd_tips/index.wiki.txt

current previous
335,23 335,6
 
}}
}}
 
引数は「%~番号」で取得できる。 このとき、引用符(")は取り除かれて展開される。 環境変数は展開されてから引数として渡されるので、値に空白が含まれていると引数の区切りとみなされ、別々に渡される点は注意が必要。 また、どちらのバッチファイルも同一プロセスで実行されるため、呼び先のバッチファイルでも呼び元の環境変数を参照することができる。
引数は「%~番号」で取得できる。 このとき、引用符(")は取り除かれて展開される。 環境変数は展開されてから引数として渡されるので、値に空白が含まれていると引数の区切りとみなされ、別々に渡される点は注意が必要。 また、どちらのバッチファイルも同一プロセスで実行されるため、呼び先のバッチファイルでも呼び元の環境変数を参照することができる。
 

        

        
+
*文字コードの変更
+
chcpコマンドを用いると、使用する文字コードを変更できる。 引数で指定できる主な文字コードは次のとおり。
+
|~コード|~名称|h
+
|932|Shift-JIS (デフォルト)|
+
|20932|EUC-JP (IS X 0208-1990 and JIS X 0212-1990)|
+
|51932|EUC-JP|
+
|65000|UTF-7|
+
|65001|UTF-8|
+

          
+
引数を指定せずにchcpコマンドを実行すると、現在の文字コードが表示される。
+

          
+
#ref(chcp-1.png,実行結果1)
+
#ref(chcp-2.png,実行結果2)
+

          
+
なお、chcpコマンドで文字コードを変更すると、ウィンドウのサイズとフォントが代わり漢字等が正しく表示されなくなるので、次の手順であらかじめフォントを変更しておく必要がある。
+
+コマンドプロンプトのプロパティを開く
+
+「フォント」タブで「MSゴシック」等のフォントに変更する
 

        

        
 
*参考資料
*参考資料
 
-[[コマンドプロンプトを使ってみよう!:http://ykr414.com/dos/index.html]]
-[[コマンドプロンプトを使ってみよう!:http://ykr414.com/dos/index.html]]

programming/netfx2/overview/stringoperation/index.wiki.txt

current previous
1,5756 1,364
 
${smdncms:title,文字列操作(System.String, System.Text)}
${smdncms:title,文字列操作(System.String, System.Text)}
+
${smdncms:keywords,String,StringBuilder,StringComparison,CompareOptions,SecureString}
 
${smdncms:meta,toc-amazonlivelink-keyword,books-jp,.net framework}
${smdncms:meta,toc-amazonlivelink-keyword,books-jp,.net framework}
~

          
#googleadunit
+
VB.NETなどの元となった言語であるBASICには、プリミティブ型として文字列型が存在していました。 この文字列型は他の言語にはない使いやすさがあり、多少の仕様変更を伴いながらもBASICからQucik BASIC、Visual Basicと変わることなく受け継がれてきました。 Visual Basic .NETおよびC#でももちろん文字列型を扱うことができますが、VBの文字列型と比較すると格段に機能が向上しています。 .NET Frameworkでは文字列に関する処理をまとめ直し、文字列型も一つのクラス型として存在するようになり、様々な機能が追加されています。
+

          
+
ここでは、文字列型であるStringクラスの機能と、文字列操作に関わる機能・クラスなどを解説します。 なお、以下のページでも文字列操作に関連することについて解説しています。
+

          
+
-関連するページ
+
--[[programming/netfx2/System.Text.RegularExpressions]]
+
--[[programming/netfx2/overview/regularexpression]]
+
--[[programming/netfx2/string_formatting]]
+

          
+
注意1: この文章ではUnicode正規形や正規化、サロゲートペアには踏み込みません。 必要に応じて他のドキュメントを参照してください。
+
注意2: この文章では一部で特殊記号を使っています。 ブラウザで使用しているフォントによっては正しく表示されない文字があるかもしれません。
+

          
+
----
+

          
 
*Stringクラス
*Stringクラス
~
**.NET FrameworkにおけるStringクラス
VB.NETなどの元となった言語であるBASICには、プリミティブ型として文字列型が存在していました。 この文字列型は他の言語にはない使いやすさがあり、多少の仕様変更を伴いながらもBASICからQucik BASIC、Visual Basicと変わることなく受け継がれてきました。 Visual Basic .NETでももちろん文字列型を扱うことができますが、VBの文字列型と比較すると格段に機能が向上しています。 というのも、文字列に関する処理をまとめ直し、VB.NETでは文字列型も一つのクラス型として存在するようになったからです。
+
Stringクラスの機能を説明する前に、.NET FrameworkにおけるStringクラスの位置づけと挙動、言語との関わりについてざっと見ておきます。
+

          
+
***文字列型とStringクラス
+
次のコードが示すように、C#のstring型、VB.NETのString型は、.NET FrameworkにおけるSystem.Stringクラスのエイリアス名で、両者は全く同じものです。
+

          
+
#tabpage(C#)
+
#code(cs){{
+
using System;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    // C#のstring型は.NET FrameworkのSystem.Stringクラスのエイリアス
+
    string s1 = "foo";
+
    System.String s2 = "bar";
+
    string s3 = new System.String(new char[] {'b', 'a', 'z'});
+

          
+
    Console.WriteLine("{0} {1}", s1, s1.GetType());
+
    Console.WriteLine("{0} {1}", s2, s2.GetType());
+
    Console.WriteLine("{0} {1}", s3, s3.GetType());
+
  }
+
}
+
}}
+
#tabpage(VB)
+
#code(vb){{
+
Imports System
+

          
+
Class Sample
+
  Shared Sub Main()
+
    ' VB.NETのString型は.NET FrameworkのSystem.Stringクラスのエイリアス
+
    Dim s1 As String = "foo"
+
    Dim s2 As System.String = "bar"
+
    Dim s3 As String = New System.String(New Char(){"b", "a", "z"})
+

          
+
    Console.WriteLine("{0} {1}", s1, s1.GetType())
+
    Console.WriteLine("{0} {1}", s2, s2.GetType())
+
    Console.WriteLine("{0} {1}", s3, s3.GetType())
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
+

          
+
#prompt(実行結果){{
+
foo System.String
+
bar System.String
+
baz System.String
+
}}
+

          
+
***参照型としての挙動
+
System.Stringはクラスであるため参照型になりますが、通常の参照型とは見かけ上の挙動が異なります。
+

          
+
#tabpage(C#)
+
#code(cs){{
+
using System;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    string s1 = "foo";
+
    string s2 = s1;
+

          
+
    Console.WriteLine("{0} {1}", s1, s2);
+

          
+
    s1 = "bar";
+

          
+
    Console.WriteLine("{0} {1}", s1, s2);
+
  }
+
}
+
}}
+
#tabpage(VB)
+
#code(vb){{
+
Imports System
+

          
+
Class Sample
+
  Shared Sub Main()
+
    Dim s1 As String = "foo"
+
    Dim s2 As String = s1
+

          
+
    Console.WriteLine("{0} {1}", s1, s2)
+

          
+
    s1 = "bar"
+

          
+
    Console.WriteLine("{0} {1}", s1, s2)
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
+

          
+
#prompt(実行結果){{
+
foo foo
+
bar foo
+
}}
+

          
+
これは、s1に"bar"を代入している箇所で、新しい文字列型のインスタンス"bar"が生成され、それがs1に代入されているためです。 上のコードは、実際には次のようなコードで動いているととらえるとわかりやすいかもしれません(擬似コードのため実際には動作しません)。
+

          
+
#tabpage(C#)
+
#code(cs){{
+
using System;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    string s1 = new string("foo");
+
    string s2 = s1;
+

          
+
    Console.WriteLine("{0} {1}", s1, s2);
+

          
+
    s1 = new string("bar");
+

          
+
    Console.WriteLine("{0} {1}", s1, s2);
+
  }
+
}
+
}}
+
#tabpage(VB)
+
#code(vb){{
+
Imports System
+

          
+
Class Sample
+
  Shared Sub Main()
+
    Dim s1 As String = New String("foo")
+
    Dim s2 As String = s1
+

          
+
    Console.WriteLine("{0} {1}", s1, s2)
+

          
+
    s1 = New String("bar")
+

          
+
    Console.WriteLine("{0} {1}", s1, s2)
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
+

          
+
***参照と等価演算子
+
C#では、文字列型同士の等価演算子==、不等価演算子!=による比較は、参照の比較ではなく文字列の等価性の比較が行われます。
+

          
+
#code(cs){{
+
using System;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    string s1 = "foo";
+
    string s2 = "bar";
+
    string s3 = "foo";
+

          
+
    Console.WriteLine(s1 == s1);
+
    Console.WriteLine(s1 == s2);
+
    Console.WriteLine(s1 == s3);
+
  }
+
}
+
}}
+

          
+
#prompt(実行結果){{
+
True
+
False
+
True
+
}}
+

          
+
C#で文字列型同士の参照の比較を行うには、いったんobjectにキャストして等価演算子==で比較するか、&msdn(netfx,method,System.Object.ReferenceEquals){Object.ReferenceEqualsメソッド};を使います。
+

          
+
#code(cs){{
+
using System;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    string s1 = "foo";
+
    string s2 = "bar";
+

          
+
    Console.WriteLine((object)s1 == (object)s2);
+
    Console.WriteLine(Object.ReferenceEquals(s1, s2));
+

          
+
    s1 = s2;
+

          
+
    Console.WriteLine((object)s1 == (object)s2);
+
    Console.WriteLine(Object.ReferenceEquals(s1, s2));
+
  }
+
}
+
}}
+

          
+
#prompt{{
+
False
+
False
+
True
+
True
+
}}
+

          
+
VB.NETでは、文字列同士のIs演算子による比較は参照の比較が行われます。 文字列の等価性の比較は行われません。
+

          
+
#code(vb){{
+
Imports System
+

          
+
Class Sample
+
  Shared Sub Main()
+
    Dim s1 As String = "foo"
+
    Dim s2 As String = "bar"
+

          
+
    Console.WriteLine(s1 Is s2)
+

          
+
    s1 = s2
+

          
+
    Console.WriteLine(s1 Is s2)
+
    Console.WriteLine(s1 Is "foo")
+
  End Sub
+
End Class
+
}}
+

          
+
#prompt(実行結果){{
+
False
+
True
+
False
+
}}
+

          
+
**Stringクラスと文字列操作
+
ここでは文字列の加工・編集の操作を行うためのメソッドについて見ていきます。
+

          
+
***連結 (Concat, +, +=)
+
&msdn(netfx,method,System.String.Concat){String.Concatメソッド};は文字列同士の連結を行う静的メソッドで、任意の数の文字列を連結出来ます。 またC#、VBでは加算演算子+、および複合代入の加算演算子+=を使った連結もできるようになっています。
+

          
+
#tabpage(C#)
+
#code(cs){{
+
using System;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    string s1 = "foo";
+
    string s2 = "bar";
+

          
+
    Console.WriteLine(s1 + s2);
+
    Console.WriteLine(s1 + s2 + "baz");
+
    Console.WriteLine(s1 + s2 + "baz" + "qux");
+

          
+
    Console.WriteLine(String.Concat(s1, s2));
+
    Console.WriteLine(String.Concat(s1, s2, "baz"));
+
    Console.WriteLine(String.Concat(s1, s2, "baz", "qux"));
+

          
+
    s1 = s1 + "baz";
+

          
+
    Console.WriteLine(s1);
+

          
+
    s2 += "quz";
+

          
+
    Console.WriteLine(s2);
+
  }
+
}
+
}}
+
#tabpage(VB)
+
#code(vb){{
+
Imports System
+

          
+
Class Sample
+
  Shared Sub Main()
+
    Dim s1 As String = "foo"
+
    Dim s2 As String = "bar"
+

          
+
    Console.WriteLine(s1 + s2)
+
    Console.WriteLine(s1 + s2 + "baz")
+
    Console.WriteLine(s1 + s2 + "baz" + "qux")
+

          
+
    Console.WriteLine(String.Concat(s1, s2))
+
    Console.WriteLine(String.Concat(s1, s2, "baz"))
+
    Console.WriteLine(String.Concat(s1, s2, "baz", "qux"))
+

          
+
    s1 = s1 + "baz"
+

          
+
    Console.WriteLine(s1)
+

          
+
    s2 += "qux"
+

          
+
    Console.WriteLine(s2)
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
+

          
+
#prompt{{
+
foobar
+
foobarbaz
+
foobarbazqux
+
foobar
+
foobarbaz
+
foobarbazqux
+
foobaz
+
barqux
+
}}
+

          
+
.NET Framework 4からは、IEnumerable<String>を引数にとるバージョンのConcatも用意されています。
+

          
+
#code(cs){{
+
using System;
+
using System.Collections.Generic;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    List<string> l = new List<string>() {"foo", "bar", "baz", "qux"};
+

          
+
    Console.WriteLine(String.Concat(l));
+
  }
+
}
+
}}
+

          
+
#prompt{{
+
foobarbazqux
+
}}
+

          
+
***複製 (Copy)
+
&msdn(netfx,method,System.String.Copy){String.Copyメソッド};は文字列の複製を行う静的メソッドです。 見かけ上の動作は文字列変数の単なる代入と似ていますが、Copyメソッドでは指定された文字列と同じ内容の新しいインスタンスが作成される点が異なります。
+

          
+
#tabpage(C#)
+
#code(cs){{
+
using System;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    string s1 = "foo";
+
    string s2;
+
    string s3;
+

          
+
    s2 = s1;
+
    s3 = String.Copy(s1);
+

          
+
    Console.WriteLine(s1);
+
    Console.WriteLine("{0} {1}", s2, Object.ReferenceEquals(s2, s1));
+
    Console.WriteLine("{0} {1}", s3, Object.ReferenceEquals(s3, s1));
+
  }
+
}
+
}}
+
#tabpage(VB)
+
#code(vb){{
+
Imports System
+

          
+
Class Sample
+
  Shared Sub Main()
+
    Dim s1 As String = "foo"
+
    Dim s2 As String
+
    Dim s3 As String
+

          
+
    s2 = s1
+
    s3 = String.Copy(s1)
+

          
+
    Console.WriteLine(s1)
+
    Console.WriteLine("{0} {1}", s2, s2 Is s1)
+
    Console.WriteLine("{0} {1}", s3, s3 Is s1)
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
+

          
+
#prompt{{
+
foo
+
foo True
+
foo False
+
}}
+

          
+
***切り出し (Substring)
+
&msdn(netfx,method,System.String.Substring){String.Substringメソッド};は文字列から部分文字列を切り出すメソッドで、切り出す最初のインデックスと長さを指定することで文字列の一部分を取得します。 長さを指定しなかった場合は、指定されたインデックスから文字列の最後までが返されます。
+

          
+
#tabpage(C#)
+
#code(cs){{
+
using System;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    string s = "The quick brown fox jumps over the lazy dog";
+

          
+
    Console.WriteLine(s.Substring(0, 9)); // 0文字目から9文字分を切り出す
+
    Console.WriteLine(s.Substring(31)); // 31文字目以降を切り出す
+
  }
+
}
+
}}
+
#tabpage(VB)
+
#code(vb){{
+
Imports System
+

          
+
Class Sample
+
  Shared Sub Main()
+
    Dim s As String = "The quick brown fox jumps over the lazy dog"
+

          
+
    Console.WriteLine(s.Substring(0, 9)) ' 0文字目から9文字分を切り出す
+
    Console.WriteLine(s.Substring(31)) ' 31文字目以降を切り出す
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
+

          
+
#prompt{{
+
The quick
+
the lazy dog
+
}}
+

          
+
***挿入 (Insert)
+
&msdn(netfx,method,System.String.Insert){String.Insertメソッド};は文字列に別の文字列を挿入するメソッドです。 Insertメソッドは別の文字列を挿入した結果を返します。
+

          
+
#tabpage(C#)
+
#code(cs){{
+
using System;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    string s = "The quick brown fox jumps over the lazy dog";
+

          
+
    Console.WriteLine(s);
+
    Console.WriteLine(s.Insert(40, "white ")); // 40文字目に"white "を挿入
+
  }
+
}
+
}}
+
#tabpage(VB)
+
#code(vb){{
+
Imports System
+

          
+
Class Sample
+
  Shared Sub Main()
+
    Dim s As String = "The quick brown fox jumps over the lazy dog"
+

          
+
    Console.WriteLine(s)
+
    Console.WriteLine(s.Insert(40, "white ")) ' 40文字目に"white "を挿入
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
+

          
+
#prompt{{
+
The quick brown fox jumps over the lazy dog
+
The quick brown fox jumps over the lazy white dog
+
}}
+

          
+
***削除 (Remove)
+
&msdn(netfx,method,System.String.Remove){String.Removeメソッド};は文字列の一部分を削除するメソッドで、削除を始める最初のインデックスと長さを指定することで文字列の一部分を削除します。 長さを指定しなかった場合は、指定されたインデックスから文字列の最後までが削除されます。
+

          
+
#tabpage(C#)
+
#code(cs){{
+
using System;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    string s = "The quick brown fox jumps over the lazy dog";
+

          
+
    Console.WriteLine(s);
+
    Console.WriteLine(s.Remove(4, 6)); // 4文字目から6文字分を削除
+
    Console.WriteLine(s.Remove(25)); // 25文字目以降を削除
+
  }
+
}
+
}}
+
#tabpage(VB)
+
#code(vb){{
+
Imports System
+

          
+
Class Sample
+
  Shared Sub Main()
+
    Dim s As String = "The quick brown fox jumps over the lazy dog"
+

          
+
    Console.WriteLine(s)
+
    Console.WriteLine(s.Remove(4, 6)) ' 4文字目から6文字分を削除
+
    Console.WriteLine(s.Remove(25)) ' 25文字目以降を削除
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
+

          
+
#prompt{{
+
The quick brown fox jumps over the lazy dog
+
The brown fox jumps over the lazy dog
+
The quick brown fox jumps
+
}}
+

          
+
位置を指定した削除ではなく、部分文字列を指定した削除にはReplaceメソッドを使用します。
+

          
+
***置換 (Replace)
+
&msdn(netfx,method,System.String.Replace){String.Replaceメソッド};は文字列内の部分文字列を別の部分文字列に置き換えるメソッドです。
+

          
+
#tabpage(C#)
+
#code(cs){{
+
using System;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    string s = "The quick brown fox jumps over the lazy dog";
+

          
+
    Console.WriteLine(s);
+
    Console.WriteLine(s.Replace("quick", "clever")); // "quick"を"clever"に置き換え
+
    Console.WriteLine(s.Replace("lazy", "silly")); // "lazy"を"silly"に置き換え
+
  }
+
}
+
}}
+
#tabpage(VB)
+
#code(vb){{
+
Imports System
+

          
+
Class Sample
+
  Shared Sub Main()
+
    Dim s As String = "The quick brown fox jumps over the lazy dog"
+

          
+
    Console.WriteLine(s)
+
    Console.WriteLine(s.Replace("quick", "clever")) ' "quick"を"clever"に置き換え
+
    Console.WriteLine(s.Replace("lazy", "silly")) ' "lazy"を"silly"に置き換え
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
+

          
+
#prompt{{
+
The quick brown fox jumps over the lazy dog
+
The clever brown fox jumps over the lazy dog
+
The quick brown fox jumps over the silly dog
+
}}
+

          
+
置き換え後の文字列にnull/Nothingもしくは空文字(String.Empty)を指定すると、置き換え前の部分文字列を削除することが出来ます。
+

          
+
#tabpage(C#)
+
#code(cs){{
+
using System;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    string s = "The quick brown fox jumps over the lazy dog";
+

          
+
    Console.WriteLine(s);
+
    Console.WriteLine(s.Replace("brown ", "")); // "brown "を削除
+
    Console.WriteLine(s.Replace("lazy ", null)); // "lazy "を削除
+
  }
+
}
+
}}
+
#tabpage(VB)
+
#code(vb){{
+
Imports System
+

          
+
Class Sample
+
  Shared Sub Main()
+
    Dim s As String = "The quick brown fox jumps over the lazy dog"
+

          
+
    Console.WriteLine(s)
+
    Console.WriteLine(s.Replace("brown ", "")) ' "brown "を削除
+
    Console.WriteLine(s.Replace("lazy ", Nothing)) ' "lazy "を削除
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
+

          
+
#prompt{{
+
The quick brown fox jumps over the lazy dog
+
The quick fox jumps over the lazy dog
+
The quick brown fox jumps over the dog
+
}}
+

          
+
また、Replaceメソッドでは文字(Char)単位での置換も行えます。
+

          
+
#tabpage(C#)
+
#code(cs){{
+
using System;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    string s = "The quick brown fox jumps over the lazy dog";
+

          
+
    Console.WriteLine(s);
+
    Console.WriteLine(s.Replace('o', 'a')); // oをaに置換
+
  }
+
}
+
}}
+
#tabpage(VB)
+
#code(vb){{
+
Imports System
+

          
+
Class Sample
+
  Shared Sub Main()
+
    Dim s As String = "The quick brown fox jumps over the lazy dog"
+

          
+
    Console.WriteLine(s);
+
    Console.WriteLine(s.Replace("o"c, "a"c)) ' oをaに置換
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
+

          
+
#prompt{{
+
The quick brown fox jumps over the lazy dog
+
The quick brawn fax jumps aver the lazy dag
+
}}
+

          
+
***分割 (Split)
+
&msdn(netfx,method,System.String.Split){String.Splitメソッド};は文字列の分割を行うメソッドで、指定した文字または文字列を区切りとして分割した結果を文字列の配列で返します。
+

          
+
#tabpage(C#)
+
#code(cs){{
+
using System;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    string s = "The quick brown fox jumps over the lazy dog";
+
    string[] words = s.Split(' '); // 文字列sを空白を区切りとして分割
+

          
+
    foreach (string word in words)
+
    {
+
      Console.WriteLine(word);
+
    }
+
  }
+
}
+
}}
+
#tabpage(VB)
+
#code(vb){{
+
Imports System
+

          
+
Class Sample
+
  Shared Sub Main()
+
    Dim s As String = "The quick brown fox jumps over the lazy dog"
+
    Dim words As String() = s.Split(" "c) ' 文字列sを空白を区切りとして分割
+

          
+
    For Each word As String In words
+
      Console.WriteLine(word)
+
    Next
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
+

          
+
#prompt{{
+
The
+
quick
+
brown
+
fox
+
jumps
+
over
+
the
+
lazy
+
dog
+
}}
+

          
+
分割時のオプションとして、分割を行った結果生じる空の要素をどう扱うかどうかを&msdn(netfx,type,System.StringSplitOptions){StringSplitOptions};で指定できます。 StringSplitOptions.RemoveEmptyEntriesを指定した場合は、空の要素は結果から取り除かれます。 StringSplitOptions.Noneはデフォルトの値で、空の要素もそのまま返されます。
+

          
+
#tabpage(C#)
+
#code(cs){{
+
using System;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    string s = "<>field1<><>field2<>field3";
+
    string[] fields;
+

          
+
    // 文字列"<>"を区切りとして分割、空の要素は削除する
+
    Console.WriteLine("StringSplitOptions.RemoveEmptyEntries");
+

          
+
    fields = s.Split(new string[] {"<>"}, StringSplitOptions.RemoveEmptyEntries);
+

          
+
    Console.WriteLine("(count = {0})", fields.Length);
+

          
+
    foreach (string field in fields)
+
    {
+
      Console.WriteLine(field);
+
    }
+

          
+
    // 文字列"<>"を区切りとして分割、空の要素は削除しない
+
    Console.WriteLine("StringSplitOptions.None");
+

          
+
    fields = s.Split(new string[] {"<>"}, StringSplitOptions.None);
+

          
+
    Console.WriteLine("(count = {0})", fields.Length);
+

          
+
    foreach (string field in fields)
+
    {
+
      Console.WriteLine(field);
+
    }
+
  }
+
}
+
}}
+
#tabpage(VB)
+
#code(vb){{
+
Imports System
+

          
+
Class Sample
+
  Shared Sub Main()
+
    Dim s As String = "<>field1<><>field2<>field3"
+
    Dim fields As String()
+

          
+
    ' 文字列"<>"を区切りとして分割、空の要素は削除する
+
    Console.WriteLine("StringSplitOptions.RemoveEmptyEntries")
+

          
+
    fields = s.Split(New String() {"<>"}, StringSplitOptions.RemoveEmptyEntries)
+

          
+
    Console.WriteLine("(count = {0})", fields.Length)
+

          
+
    For Each field As String In fields
+
      Console.WriteLine(field)
+
    Next
+

          
+
    ' 文字列"<>"を区切りとして分割、空の要素は削除しない
+
    Console.WriteLine("StringSplitOptions.None")
+

          
+
    fields = s.Split(New String() {"<>"}, StringSplitOptions.None)
+

          
+
    Console.WriteLine("(count = {0})", fields.Length)
+

          
+
    For Each field As String In fields
+
      Console.WriteLine(field)
+
    Next
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
+

          
+
#prompt{{
+
StringSplitOptions.RemoveEmptyEntries
+
(count = 3)
+
field1
+
field2
+
field3
+
StringSplitOptions.None
+
(count = 5)
+

          
+
field1
+

          
+
field2
+
field3
+
}}
+

          
+
***結合 (Join)
+
&msdn(netfx,method,System.String.Join){String.Joinメソッド};は配列の結合を行う静的メソッドで、結合時の区切り文字と配列を指定し、それらを結合した結果を返します。
+

          
+
#tabpage(C#)
+
#code(cs){{
+
using System;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    string[] words = new string[] {"The", "quick", "brown", "fox", "jumps", "over", "the", "lazy", "dog"};
+

          
+
    Console.WriteLine(String.Join(" ", words)); // 区切り文字を" "として結合
+
    Console.WriteLine(String.Join("<>", words)); // 区切り文字を"<>"として結合
+
  }
+
}
+
}}
+
#tabpage(VB)
+
#code(vb){{
+
Imports System
+

          
+
Class Sample
+
  Shared Sub Main()
+
    Dim words As String() = New String() {"The", "quick", "brown", "fox", "jumps", "over", "the", "lazy", "dog"}
+

          
+
    Console.WriteLine(String.Join(" ", words)) ' 区切り文字を" "として結合
+
    Console.WriteLine(String.Join("<>", words)) ' 区切り文字を"<>"として結合
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
+

          
+
#prompt{{
+
The quick brown fox jumps over the lazy dog
+
The<>quick<>brown<>fox<>jumps<>over<>the<>lazy<>dog
+
}}
+

          
+
.NET Framework 4からは、IEnumerable<String>を引数にとるバージョンのJoinも用意されています。
+

          
+
#code(cs){{
+
using System;
+
using System.Collections.Generic;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    List<string> l = new List<string>() {"The", "quick", "brown", "fox", "jumps", "over", "the", "lazy", "dog"};
+

          
+
    Console.WriteLine(String.Join(", ", l));
+
  }
+
}
+
}}
+

          
+
#prompt{{
+
The, quick, brown, fox, jumps, over, the, lazy, dog
+
}}
+

          
+
***余白の削除 (Trim, TrimEnd, TrimStart)
+
&msdn(netfx,method,System.String.Trim){String.Trimメソッド};は文字列の先頭と末尾にある空白文字を削除するメソッドです。 &msdn(netfx,method,System.String.TrimStart){String.TrimStartメソッド};では先頭のみ、&msdn(netfx,method,System.String.TrimEnd){String.TrimEndメソッド};では末尾のみにある空白文字を削除します。
+

          
+
#tabpage(C#)
+
#code(cs){{
+
using System;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    string s = "   The quick brown fox jumps over the lazy dog   ";
+

          
+
    Console.WriteLine("<{0}>", s);
+
    Console.WriteLine("<{0}>", s.Trim());
+
    Console.WriteLine("<{0}>", s.TrimStart());
+
    Console.WriteLine("<{0}>", s.TrimEnd());
+
  }
+
}
+
}}
+
#tabpage(VB)
+
#code(vb){{
+
Imports System
+

          
+
Class Sample
+
  Shared Sub Main()
+
    Dim s As String = "   The quick brown fox jumps over the lazy dog   "
+

          
+
    Console.WriteLine("<{0}>", s)
+
    Console.WriteLine("<{0}>", s.Trim())
+
    Console.WriteLine("<{0}>", s.TrimStart())
+
    Console.WriteLine("<{0}>", s.TrimEnd())
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
+

          
+
#prompt{{
+
<   The quick brown fox jumps over the lazy dog   >
+
<The quick brown fox jumps over the lazy dog>
+
<The quick brown fox jumps over the lazy dog   >
+
<   The quick brown fox jumps over the lazy dog>
+
}}
+

          
+
空白文字として扱われる文字には、スペース、タブの他、改行文字も含まれます。 詳細は.NET Frameworkのドキュメントを参照してください。
+

          
+
また、削除する文字を指定することも出来ます。 この場合、スペース以外の文字も指定することが出来ます。
+

          
+
#tabpage(C#)
+
#code(cs){{
+
using System;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    string s = "123abc456def7890";
+
    char[] numbers = new char[] {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9'};
+

          
+
    Console.WriteLine(s);
+
    Console.WriteLine(s.Trim(numbers)); // 先頭と末尾の数字を削除
+
    Console.WriteLine(s.TrimStart(numbers)); // 先頭と数字を削除
+
    Console.WriteLine(s.TrimEnd(numbers)); // 末尾の数字を削除
+
  }
+
}
+
}}
+
#tabpage(VB)
+
#code(vb){{
+
Imports System
+

          
+
Class Sample
+
  Shared Sub Main()
+
    Dim s As String = "123abc456def7890"
+
    Dim numbers As Char() = New Char() {"0"c, "1"c, "2"c, "3"c, "4"c, "5"c, "6"c, "7"c, "8"c, "9"c}
+

          
+
    Console.WriteLine(s)
+
    Console.WriteLine(s.Trim(numbers)) ' 先頭と末尾の数字を削除
+
    Console.WriteLine(s.TrimStart(numbers)) ' 先頭と数字を削除
+
    Console.WriteLine(s.TrimEnd(numbers)) ' 末尾の数字を削除
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
+

          
+
#prompt{{
+
123abc456def7890
+
abc456def
+
abc456def7890
+
123abc456def
+
}}
+

          
+
***余白の挿入 (PadLeft, PadRight)
+
&msdn(netfx,method,System.String.PadLeft){String.PadLeftメソッド};は余白の挿入を行うメソッドで、指定された文字数になるように左側にスペースを挿入します。 &msdn(netfx,method,System.String.PadRight){String.PadRightメソッド};はPadLeftメソッドとは逆に右側にスペースを挿入します。 指定された文字数より文字列の長さの方が大きい場合、スペースは挿入されません。
+

          
+
#tabpage(C#)
+
#code(cs){{
+
using System;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    string s = "foo";
+

          
+
    Console.WriteLine("<{0}>", s.PadLeft(6)); // 文字数が6になるように左側に余白を挿入
+
    Console.WriteLine("<{0}>", s.PadRight(6)); // 文字数が6になるように右側に余白を挿入
+
    Console.WriteLine("<{0}>", s.PadLeft(2)); // 文字数が2になるように左側に余白を挿入
+
    Console.WriteLine("<{0}>", s.PadRight(2)); // 文字数が2になるように右側に余白を挿入
+
  }
+
}
+
}}
+
#tabpage(VB)
+
#code(vb){{
+
Imports System
+

          
+
Class Sample
+
  Shared Sub Main()
+
    Dim s As String = "foo"
+

          
+
    Console.WriteLine("<{0}>", s.PadLeft(6)) ' 文字数が6になるように左側に余白を挿入
+
    Console.WriteLine("<{0}>", s.PadRight(6)) ' 文字数が6になるように右側に余白を挿入
+
    Console.WriteLine("<{0}>", s.PadLeft(2)) ' 文字数が2になるように左側に余白を挿入
+
    Console.WriteLine("<{0}>", s.PadRight(2)) ' 文字数が2になるように右側に余白を挿入
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
+

          
+
#prompt{{
+
<   foo>
+
<foo   >
+
<foo>
+
<foo>
+
}}
+

          
+
スペース以外の文字を挿入するように指定することも出来ます。
+

          
+
#tabpage(C#)
+
#code(cs){{
+
using System;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    string s = "foo";
+

          
+
    Console.WriteLine("<{0}>", s.PadLeft(6, '*')); // 文字数が6になるように左側に'*'を挿入
+
    Console.WriteLine("<{0}>", s.PadRight(6, '-')); // 文字数が6になるように右側に'-'を挿入
+
  }
+
}
+
}}
+
#tabpage(VB)
+
#code(vb){{
+
Imports System
+

          
+
Class Sample
+
  Shared Sub Main()
+
    Dim s As String = "foo"
+

          
+
    Console.WriteLine("<{0}>", s.PadLeft(6, "*"c)) ' 文字数が6になるように左側に'*'を挿入
+
    Console.WriteLine("<{0}>", s.PadRight(6, "-"c)) ' 文字数が6になるように右側に'-'を挿入
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
+

          
+
#prompt{{
+
<***foo>
+
<foo--->
+
}}
+

          
+
***大文字化・小文字化 (ToUpper, ToLower, ToUpperInvariant, ToLowerInvariant)
+
&msdn(netfx,method,System.String.ToUpper){String.ToUpperメソッド};は文字列を大文字化するメソッド、&msdn(netfx,method,System.String.ToLower){String.ToLowerメソッド};は文字列を小文字化するメソッドです。
+

          
+
ToUpperメソッドとToLowerメソッドは現在のスレッドの(もしくは引数で指定された)カルチャの規則に基づいて大文字化・小文字化しますが、&msdn(netfx,method,System.String.ToUpperInvariant){String.ToUpperInvariantメソッド};と&msdn(netfx,method,System.String.ToLowerInvariant){String.ToLowerInvariantメソッド};はインバリアントカルチャ(特定の文化圏や言語に依存しない)の規則に基づいて大文字化・小文字化します。
+

          
+
#tabpage(C#)
+
#code(cs){{
+
using System;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    string s = "The Quick Brown Fox Jumps Over The Lazy Dog";
+

          
+
    Console.WriteLine(s);
+
    Console.WriteLine(s.ToUpper());
+
    Console.WriteLine(s.ToUpperInvariant());
+
    Console.WriteLine(s.ToLower());
+
    Console.WriteLine(s.ToLowerInvariant());
+
  }
+
}
+
}}
+
#tabpage(VB)
+
#code(vb){{
+
Imports System
+

          
+
Class Sample
+
  Shared Sub Main()
+
    Dim s As String = "The Quick Brown Fox Jumps Over The Lazy Dog"
+

          
+
    Console.WriteLine(s)
+
    Console.WriteLine(s.ToUpper())
+
    Console.WriteLine(s.ToUpperInvariant())
+
    Console.WriteLine(s.ToLower())
+
    Console.WriteLine(s.ToLowerInvariant())
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
+

          
+
#prompt{{
+
The Quick Brown Fox Jumps Over The Lazy Dog
+
THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG
+
THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG
+
the quick brown fox jumps over the lazy dog
+
the quick brown fox jumps over the lazy dog
+
}}
+

          
+
ToUpper/ToUpperInvariantとToLower/ToLowerInvariantの違いは、大文字化・小文字化の際に参照される規則です。 例えば、トルコ語においては''i''の大文字は''I''(U+0049)ではなく''İ''(U+0131)で、''I''の小文字は''i''(U+0069)ではなく''ı''(U+0130)となるため、スレッドのカルチャがトルコ語の場合ToUpper/ToLowerの結果はToUpperInvariant/ToLowerInvariantと異なります。
+

          
+
#tabpage(C#)
+
#code(cs){{
+
using System;
+
using System.Globalization;
+
using System.Threading;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    Console.WriteLine(Thread.CurrentThread.CurrentCulture);
+
    Console.WriteLine("i: {0} {1}", "i".ToUpperInvariant(), "i".ToUpper());
+
    Console.WriteLine("I: {0} {1}", "I".ToLowerInvariant(), "I".ToLower());
+

          
+
    // 現在のスレッドのカルチャをtr-TR(トルコ語/トルコ)に変更
+
    Thread.CurrentThread.CurrentCulture = CultureInfo.GetCultureInfo("tr-TR");
+

          
+
    Console.WriteLine(Thread.CurrentThread.CurrentCulture);
+
    Console.WriteLine("i: {0} {1}", "i".ToUpperInvariant(), "i".ToUpper());
+
    Console.WriteLine("I: {0} {1}", "I".ToLowerInvariant(), "I".ToLower());
+
  }
+
}
+
}}
+
#tabpage(VB)
+
#code(vb){{
+
Imports System
+
Imports System.Globalization
+
Imports System.Threading
+

          
+
Class Sample
+
  Shared Sub Main()
+
    Console.WriteLine(Thread.CurrentThread.CurrentCulture)
+
    Console.WriteLine("i: {0} {1}", "i".ToUpperInvariant(), "i".ToUpper())
+
    Console.WriteLine("I: {0} {1}", "I".ToLowerInvariant(), "I".ToLower())
+

          
+
    ' 現在のスレッドのカルチャをtr-TR(トルコ語/トルコ)に変更
+
    Thread.CurrentThread.CurrentCulture = CultureInfo.GetCultureInfo("tr-TR")
+

          
+
    Console.WriteLine(Thread.CurrentThread.CurrentCulture)
+
    Console.WriteLine("i: {0} {1}", "i".ToUpperInvariant(), "i".ToUpper())
+
    Console.WriteLine("I: {0} {1}", "I".ToLowerInvariant(), "I".ToLower())
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
+

          
+
#prompt{{
+
ja-JP
+
i: I I
+
I: i i
+
tr-TR
+
i: I İ
+
I: i ı
+
}}
+

          
+
したがって、カルチャや変換規則を強く意識する必要がある場合はToUpper/ToLowerを用いる必要があり、それ以外の多くの場合はToUpperInvariant/ToLowerInvariantで十分と言えます。 カルチャと変換規則については[[StringComparisonとStringComparer>#StringComparisonStringComparer]]でも詳しく説明します。
+

          
+
***書式化 (Format)
+
&msdn(netfx,method,System.String.Format){String.Formatメソッド};は任意の引数を指定された書式に基づいて文字列化する静的メソッドです。
+

          
+
#tabpage(C#)
+
#code(cs){{
+
using System;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    DateTime dateTimeValue = new DateTime(2010, 9, 14, 1, 2, 3);
+
    string s = String.Format("{1:r}   {0:D}   {0:D4}   {0:N4}", 72, dateTimeValue);
+

          
+
    Console.WriteLine(s);
+
  }
+
}
+
}}
+
#tabpage(VB)
+
#code(vb){{
+
Imports System
+

          
+
Class Sample
+
  Shared Sub Main()
+
    Dim dateTimeValue As New DateTime(2010, 9, 14, 1, 2, 3)
+
    Dim s As String = String.Format("{1:r}   {0:D}   {0:D4}   {0:N4}", 72, dateTimeValue)
+

          
+
    Console.WriteLine(s)
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
+

          
+
#prompt{{
+
Tue, 14 Sep 2010 01:02:03 GMT   72   0072   72.0000
+
}}
+

          
+
書式の詳細については[[programming/netfx2/string_formatting]]で解説しているので、そちらを参照してください。
+

          
+
***Char配列への変換 (ToCharArray, CopyTo)
+
&msdn(netfx,method,System.String.ToCharArray){String.ToCharArrayメソッド};は文字列をChar配列へ変換するメソッドです。
+

          
+
#tabpage(C#)
+
#code(cs){{
+
using System;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    string s = "The quick brown fox jumps over the lazy dog";
+
    char[] chars;
+

          
+
    chars = s.ToCharArray();
+

          
+
    for (int i = 0; i < chars.Length; i++)
+
    {
+
      Console.Write(chars[i]);
+
    }
+

          
+
    Console.WriteLine();
+

          
+
    // 配列を反転して表示
+
    Array.Reverse(chars);
+

          
+
    for (int i = 0; i < chars.Length; i++)
+
    {
+
      Console.Write(chars[i]);
+
    }
+

          
+
    Console.WriteLine();
+
  }
+
}
+
}}
+
#tabpage(VB)
+
#code(vb){{
+
Imports System
+

          
+
Class Sample
+
  Shared Sub Main()
+
    Dim s As String = "The quick brown fox jumps over the lazy dog"
+
    Dim chars As Char()
+

          
+
    chars = s.ToCharArray()
+

          
+
    For i As Integer = 0 To chars.Length - 1
+
      Console.Write(chars(i))
+
    Next
+

          
+
    Console.WriteLine()
+

          
+
    ' 配列を反転して表示
+
    Array.Reverse(chars)
+

          
+
    For i As Integer = 0 To chars.Length - 1
+
      Console.Write(chars(i))
+
    Next
+

          
+
    Console.WriteLine()
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
+

          
+
#prompt{{
+
The quick brown fox jumps over the lazy dog
+
god yzal eht revo spmuj xof nworb kciuq ehT
+
}}
+

          
+
&msdn(netfx,method,System.String.CopyTo){String.CopyToメソッド};は、文字列の一部のみを別のChar配列にコピーするメソッドです。 ToCharArrayメソッドとは異なり、コピー先のChar配列をあらかじめ用意しておく必要があります。
+

          
+
#tabpage(C#)
+
#code(cs){{
+
using System;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    string s = "The quick brown fox jumps over the lazy dog";
+
    char[] chars = new char[11]; // コピー先となる配列
+

          
+
    s.CopyTo(4, chars, 0, 11); // 文字列の4文字目から11文字分を、コピー先配列のインデックス0を起点にコピー
+

          
+
    for (int i = 0; i < chars.Length; i++)
+
    {
+
      Console.Write("{0}/", chars[i]);
+
    }
+

          
+
    Console.WriteLine();
+
  }
+
}
+
}}
+
#tabpage(VB)
+
#code(vb){{
+
Imports System
+

          
+
Class Sample
+
  Shared Sub Main()
+
    Dim s As String = "The quick brown fox jumps over the lazy dog"
+
    Dim chars(10) As Char ' コピー先となる配列
+

          
+
    s.CopyTo(4, chars, 0, 11) ' 文字列の4文字目から11文字分を、コピー先配列のインデックス0を起点にコピー
+

          
+
    For i As Integer = 0 To chars.Length - 1
+
      Console.Write("{0}/", chars(i))
+
    Next
+

          
+
    Console.WriteLine()
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
+

          
+
#prompt{{
+
q/u/i/c/k/ /b/r/o/w/n/
+
}}
+

          
+
***Char配列からの変換 (Stringコンストラクタ)
+
StringクラスのコンストラクタにChar配列を指定することにより、Char配列から文字列へ変換することが出来ます。
+

          
+
#tabpage(C#)
+
#code(cs){{
+
using System;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    char[] chars = new char[] {'b', 'a', 'r'};
+
    string s = new string(chars);
+

          
+
    Console.WriteLine(s);
+

          
+
    Array.Reverse(chars);
+

          
+
    Console.WriteLine(new string(chars));
+
  }
+
}
+
}}
+
#tabpage(VB)
+
#code(vb){{
+
Imports System
+

          
+
Class Sample
+
  Shared Sub Main()
+
    Dim chars As Char() = New Char() {"b"c, "a"c, "r"c}
+
    Dim s As New String(chars)
+

          
+
    Console.WriteLine(s)
+

          
+
    Array.Reverse(chars)
+

          
+
    Console.WriteLine(New String(chars))
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
+

          
+
#prompt{{
+
bar
+
rab
+
}}
+

          
+
また、マネージドコードのみの場合はほとんど使うことはありませんが、charのポインタやsbyteのポインタから文字列を作成することも出来ます。
+

          
+
#code(cs){{
+
using System;
+
using System.Text;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    byte[] data;
+
    string s;
+

          
+
    data = new byte[] {0x41, 0x42, 0x43};
+

          
+
    unsafe
+
    {
+
      fixed (byte* d = data)
+
      {
+
        s = new string((sbyte*)d, 0, 3);
+
      }
+
    }
+

          
+
    Console.WriteLine(s);
+

          
+
    data = new byte[] {0x93, 0xfa, 0x96, 0x7b, 0x8c, 0xea};
+

          
+
    unsafe
+
    {
+
      fixed (byte* d = data)
+
      {
+
        s = new string((sbyte*)d, 0, 6, Encoding.GetEncoding("shift_jis"));
+
      }
+
    }
+

          
+
    Console.WriteLine(s);
+
  }
+
}
+
}}
+

          
+
#prompt{{
+
ABC
+
日本語
+
}}
+

          
+
**Stringクラスと文字列の検索・比較・等価性の検証
+
ここでは文字列の検索・比較・等価性の検証などを行うためのメソッドについて見ていきます。
+

          
+
***null、空文字、空白のチェック (IsNullOrEmpty, IsNullOrWhiteSpace)
+
&msdn(netfx,method,System.String.IsNullOrEmpty){String.IsNullOrEmptyメソッド};は文字列がnull/Nothingもしくは空文字かどうかをチェックする静的メソッドです。 &msdn(netfx,method,System.String.IsNullOrWhiteSpace){String.IsNullOrWhiteSpaceメソッド};は.NET Framework 4から追加されたメソッドで、文字列がnull/Nothingもしくは空文字か、空白文字のみで構成されているかどうかをチェックする静的メソッドです。
+

          
+
#tabpage(C#)
+
#code(cs){{
+
using System;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    string s = "foo";
+

          
+
    Console.WriteLine("<{0}> : IsNullOrEmpty = {1}", s, String.IsNullOrEmpty(s));
+
    Console.WriteLine("<{0}> : IsNullOrWhiteSpace = {1}", s, String.IsNullOrWhiteSpace(s));
+

          
+
    s = "   "; // 空白のみの文字列
+

          
+
    Console.WriteLine("<{0}> : IsNullOrEmpty = {1}", s, String.IsNullOrEmpty(s));
+
    Console.WriteLine("<{0}> : IsNullOrWhiteSpace = {1}", s, String.IsNullOrWhiteSpace(s));
+

          
+
    s = ""; // 空(長さ0)の文字列
+

          
+
    Console.WriteLine("<{0}> : IsNullOrEmpty = {1}", s, String.IsNullOrEmpty(s));
+
    Console.WriteLine("<{0}> : IsNullOrWhiteSpace = {1}", s, String.IsNullOrWhiteSpace(s));
+

          
+
    s = null; // nullが代入されている文字列変数
+

          
+
    Console.WriteLine("<{0}> : IsNullOrEmpty = {1}", s, String.IsNullOrEmpty(s));
+
    Console.WriteLine("<{0}> : IsNullOrWhiteSpace = {1}", s, String.IsNullOrWhiteSpace(s));
+
  }
+
}
+
}}
+
#tabpage(VB)
+
#code(vb){{
+
Imports System
+

          
+
Class Sample
+
  Shared Sub Main()
+
    Dim s As String = "foo"
+

          
+
    Console.WriteLine("<{0}> : IsNullOrEmpty = {1}", s, String.IsNullOrEmpty(s))
+
    Console.WriteLine("<{0}> : IsNullOrWhiteSpace = {1}", s, String.IsNullOrWhiteSpace(s))
+

          
+
    s = "   " ' 空白のみの文字列
+

          
+
    Console.WriteLine("<{0}> : IsNullOrEmpty = {1}", s, String.IsNullOrEmpty(s))
+
    Console.WriteLine("<{0}> : IsNullOrWhiteSpace = {1}", s, String.IsNullOrWhiteSpace(s))
+

          
+
    s = "" ' 空(長さ0)の文字列
+

          
+
    Console.WriteLine("<{0}> : IsNullOrEmpty = {1}", s, String.IsNullOrEmpty(s))
+
    Console.WriteLine("<{0}> : IsNullOrWhiteSpace = {1}", s, String.IsNullOrWhiteSpace(s))
+

          
+
    s = Nothing ' Nothingが代入されている文字列変数
+

          
+
    Console.WriteLine("<{0}> : IsNullOrEmpty = {1}", s, String.IsNullOrEmpty(s))
+
    Console.WriteLine("<{0}> : IsNullOrWhiteSpace = {1}", s, String.IsNullOrWhiteSpace(s))
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
+

          
+
#prompt{{
+
<foo> : IsNullOrEmpty = False
+
<foo> : IsNullOrWhiteSpace = False
+
<   > : IsNullOrEmpty = False
+
<   > : IsNullOrWhiteSpace = True
+
<> : IsNullOrEmpty = True
+
<> : IsNullOrWhiteSpace = True
+
<> : IsNullOrEmpty = True
+
<> : IsNullOrWhiteSpace = True
+
}}
+

          
+
空白文字として扱われる文字には、スペース、タブの他、改行文字も含まれます。 詳細は.NET Frameworkのドキュメントを参照してください。
+

          
+
なお、IsNullOrEmptyメソッド、IsNullOrWhiteSpaceメソッドの動作は、次のコードと等価です。
+

          
+
#tabpage(C#)
+
#code(cs){{
+
static bool IsNullOrEmpty(string s)
+
{
+
  if (s == null)
+
    return true;
+
  else if (s.Length == 0)
+
    return true;
+
  else
+
    return false;
+
}
+

          
+
static bool IsNullOrWhiteSpace(string s)
+
{
+
  if (IsNullOrEmpty(s))
+
    return true;
+
  else if (s.Trim().Length == 0)
+
    return true;
+
  else
+
    return false;
+
}
+
}}
+
#tabpage(VB)
+
#code(vb){{
+
Shared Function IsNullOrEmpty(ByVal s As String) As Boolean
+
  If s Is Nothing Then
+
    Return True
+
  Else If s.Length = 0 Then
+
    Return True
+
  Else
+
    Return False
+
  End If
+
End Function
+

          
+
Shared Function IsNullOrWhiteSpace(ByVal s As String) As Boolean
+
  If IsNullOrEmpty(s) Then
+
    Return True
+
  Else If s.Trim().Length = 0 Then
+
    Return True
+
  Else
+
    Return False
+
  End If
+
End Function
+
}}
+
#tabpage-end
+

          
+
***部分文字列の検索 (IndexOf, LastIndexOf)
+
&msdn(netfx,method,System.String.IndexOf){String.IndexOfメソッド};は文字列内にある部分文字列の位置を検索するメソッドで、文字列内にある部分文字列の最初のインデックスを返します。 文字列内に部分文字列がない場合は-1が返されます。
+

          
+
#tabpage(C#)
+
#code(cs){{
+
using System;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    string s = "The quick brown fox jumps over the lazy dog";
+

          
+
    Console.WriteLine(s.IndexOf("fox"));
+
    Console.WriteLine(s.IndexOf("lazy dog"));
+
    Console.WriteLine(s.IndexOf("cat"));
+
  }
+
}
+
}}
+
#tabpage(VB)
+
#code(vb){{
+
Imports System
+

          
+
Class Sample
+
  Shared Sub Main()
+
    Dim s As String = "The quick brown fox jumps over the lazy dog"
+

          
+
    Console.WriteLine(s.IndexOf("fox"))
+
    Console.WriteLine(s.IndexOf("lazy dog"))
+
    Console.WriteLine(s.IndexOf("cat"))
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
+

          
+
#prompt{{
+
16
+
35
+
-1
+
}}
+

          
+
&msdn(netfx,method,System.String.LastIndexOf){String.LastIndexOfメソッド};はIndexOfメソッドとは異なり、後ろから検索を行い、文字列内にある部分文字列の最後のインデックスを返します。 文字列内に部分文字列がない場合はIndexOfメソッドと同様に-1が返されます。
+

          
+
#tabpage(C#)
+
#code(cs){{
+
using System;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    string s = "foo bar foo";
+

          
+
    Console.WriteLine(s.IndexOf("foo"));
+
    Console.WriteLine(s.LastIndexOf("foo"));
+
    Console.WriteLine(s.IndexOf("baz"));
+
    Console.WriteLine(s.LastIndexOf("baz"));
+
  }
+
}
+
}}
+
#tabpage(VB)
+
#code(vb){{
+
Imports System
+

          
+
Class Sample
+
  Shared Sub Main()
+
    Dim s As String = "foo bar foo"
+

          
+
    Console.WriteLine(s.IndexOf("foo"))
+
    Console.WriteLine(s.LastIndexOf("foo"))
+
    Console.WriteLine(s.IndexOf("baz"))
+
    Console.WriteLine(s.LastIndexOf("baz"))
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
+

          
+
#prompt{{
+
0
+
8
+
-1
+
-1
+
}}
+

          
+
IndexOfメソッド、LastIndexOfメソッドでは、文字列比較時のオプションを指定することができ、例えば大文字小文字の違いを無視した検索を行うことも出来ます。 文字列比較時のオプションについては[[StringComparisonとStringComparer>#StringComparisonStringComparer]]で詳しく説明します。
+

          
+
#tabpage(C#)
+
#code(cs){{
+
using System;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    string s = "foo bar foo";
+

          
+
    Console.WriteLine(s.IndexOf("FOO", StringComparison.CurrentCulture));
+
    Console.WriteLine(s.IndexOf("FOO", StringComparison.CurrentCultureIgnoreCase));
+
    Console.WriteLine(s.LastIndexOf("FOO", StringComparison.CurrentCulture));
+
    Console.WriteLine(s.LastIndexOf("FOO", StringComparison.CurrentCultureIgnoreCase));
+
  }
+
}
+
}}
+
#tabpage(VB)
+
#code(vb){{
+
Imports System
+

          
+
Class Sample
+
  Shared Sub Main()
+
    Dim s As String = "foo bar foo"
+

          
+
    Console.WriteLine(s.IndexOf("FOO", StringComparison.CurrentCulture))
+
    Console.WriteLine(s.IndexOf("FOO", StringComparison.CurrentCultureIgnoreCase))
+
    Console.WriteLine(s.LastIndexOf("FOO", StringComparison.CurrentCulture))
+
    Console.WriteLine(s.LastIndexOf("FOO", StringComparison.CurrentCultureIgnoreCase))
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
+

          
+
#prompt{{
+
-1
+
0
+
-1
+
8
+
}}
+

          
+
***任意の文字の検索 (IndexOfAny, LastIndexOfAny)
+
&msdn(netfx,method,System.String.IndexOfAny){String.IndexOfAnyメソッド};は指定された複数の文字の中で、文字列内で見つかった最初の位置を検索するメソッドです。 IndexOfメソッド同様、いずれの文字も見つからなかった場合は-1が返されます。
+

          
+
#tabpage(C#)
+
#code(cs){{
+
using System;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    string s = "The quick brown fox jumps over the lazy dog";
+

          
+
    // q, w, eのいずれかの文字が最初に現れる位置を取得する
+
    Console.WriteLine(s.IndexOfAny(new char[] {'q', 'w', 'e'}));
+

          
+
    // R, T, Yのいずれかの文字が最初に現れる位置を取得する
+
    Console.WriteLine(s.IndexOfAny(new char[] {'R', 'T', 'Y'}));
+
  }
+
}
+
}}
+
#tabpage(VB)
+
#code(vb){{
+
Imports System
+

          
+
Class Sample
+
  Shared Sub Main()
+
    Dim s As String = "The quick brown fox jumps over the lazy dog"
+

          
+
    ' q, w, eのいずれかの文字が最初に現れる位置を取得する
+
    Console.WriteLine(s.IndexOfAny(New Char() {"q"c, "w"c, "e"c}))
+

          
+
    ' R, T, Yのいずれかの文字が最初に現れる位置を取得する
+
    Console.WriteLine(s.IndexOfAny(New Char() {"R"c, "T"c, "Y"c}))
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
+

          
+
#prompt{{
+
2
+
0
+
}}
+

          
+
&msdn(netfx,method,System.String.LastIndexOfAny){String.LastIndexOfAnyメソッド};は、後ろから検索を行い、文字列内で見つかった最後の位置を返します。
+

          
+
#tabpage(C#)
+
#code(cs){{
+
using System;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    string s = "The quick brown fox jumps over the lazy dog";
+

          
+
    // a, e, oのいずれかの文字が最初に現れる位置を取得する
+
    Console.WriteLine(s.IndexOfAny(new char[] {'a', 'e', 'o'}));
+

          
+
    // a, e, oのいずれかの文字が最後に現れる位置を取得する
+
    Console.WriteLine(s.LastIndexOfAny(new char[] {'a', 'e', 'o'}));
+
  }
+
}
+
}}
+
#tabpage(VB)
+
#code(vb){{
+
Imports System
+

          
+
Class Sample
+
  Shared Sub Main()
+
    Dim s As String = "The quick brown fox jumps over the lazy dog"
+

          
+
    ' a, e, oのいずれかの文字が最初に現れる位置を取得する
+
    Console.WriteLine(s.IndexOfAny(New Char() {"a"c, "e"c, "o"c}))
+

          
+
    ' a, e, oのいずれかの文字が最後に現れる位置を取得する
+
    Console.WriteLine(s.LastIndexOfAny(New Char() {"a"c, "e"c, "o"c}))
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
+

          
+
#prompt{{
+
2
+
41
+
}}
+

          
+
***部分文字列の一致 (Contains, StartsWith, EndsWith)
+
&msdn(netfx,method,System.String.Contains){String.Containsメソッド};は文字列中に部分文字列が含まれているかどうかを調べるメソッドです。 部分文字列が含まれている場合(=IndexOfメソッドの結果が-1以外となる場合)はtrueが返されます。
+

          
+
#tabpage(C#)
+
#code(cs){{
+
using System;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    string s = "The quick brown fox jumps over the lazy dog";
+

          
+
    Console.WriteLine(s.Contains("fox"));
+
    Console.WriteLine(s.Contains("lazy dog"));
+
    Console.WriteLine(s.Contains("cat"));
+
  }
+
}
+
}}
+
#tabpage(VB)
+
#code(vb){{
+
Imports System
+

          
+
Class Sample
+
  Shared Sub Main()
+
    Dim s As String = "The quick brown fox jumps over the lazy dog"
+

          
+
    Console.WriteLine(s.Contains("fox"))
+
    Console.WriteLine(s.Contains("lazy dog"))
+
    Console.WriteLine(s.Contains("cat"))
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
+

          
+
#prompt{{
+
True
+
True
+
False
+
}}
+

          
+
&msdn(netfx,method,System.String.StartsWith){String.StartsWithメソッド};は文字列が指定された部分文字列で始まるかどうかを調べるメソッドです。 逆に、&msdn(netfx,method,System.String.EndsWith){String.EndsWithメソッド};は部分文字列で終わるかどうかを調べるメソッドです。
+

          
+
#tabpage(C#)
+
#code(cs){{
+
using System;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    string s = "The quick brown fox jumps over the lazy dog";
+

          
+
    Console.WriteLine(s.StartsWith("The"));  // 文字列が"The"で始まるか
+
    Console.WriteLine(s.StartsWith("lazy")); // 文字列が"lazy"で始まるか
+
    Console.WriteLine(s.EndsWith("dog"));    // 文字列が"dog"で終わるか
+
    Console.WriteLine(s.EndsWith("cat"));    // 文字列が"cat"で終わるか
+
  }
+
}
+
}}
+
#tabpage(VB)
+
#code(vb){{
+
Imports System
+

          
+
Class Sample
+
  Shared Sub Main()
+
    Dim s As String = "The quick brown fox jumps over the lazy dog"
+

          
+
    Console.WriteLine(s.StartsWith("The"))  ' 文字列が"The"で始まるか
+
    Console.WriteLine(s.StartsWith("lazy")) ' 文字列が"lazy"で始まるか
+
    Console.WriteLine(s.EndsWith("dog"))    ' 文字列が"dog"で終わるか
+
    Console.WriteLine(s.EndsWith("cat"))    ' 文字列が"cat"で終わるか
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
+

          
+
#prompt{{
+
True
+
False
+
True
+
False
+
}}
+

          
+
StartsWithメソッド、EndsWithメソッドでは、文字列比較時のオプションを指定することができ、例えば大文字小文字の違いを無視して部分文字列が一致するかどうかを調べることも出来ます。 文字列比較時のオプションについては[[StringComparisonとStringComparer>#StringComparisonStringComparer]]で詳しく説明します。
+

          
+
#tabpage(C#)
+
#code(cs){{
+
using System;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    string s = "The quick brown fox jumps over the lazy dog";
+

          
+
    Console.WriteLine(s.StartsWith("the", StringComparison.CurrentCulture));
+
    Console.WriteLine(s.StartsWith("the", StringComparison.CurrentCultureIgnoreCase));
+
    Console.WriteLine(s.EndsWith("DOG", StringComparison.CurrentCulture));
+
    Console.WriteLine(s.EndsWith("DOG", StringComparison.CurrentCultureIgnoreCase));
+
  }
+
}
+
}}
+
#tabpage(VB)
+
#code(vb){{
+
Imports System
+

          
+
Class Sample
+
  Shared Sub Main()
+
    Dim s As String = "The quick brown fox jumps over the lazy dog"
+

          
+
    Console.WriteLine(s.StartsWith("the", StringComparison.CurrentCulture))
+
    Console.WriteLine(s.StartsWith("the", StringComparison.CurrentCultureIgnoreCase))
+
    Console.WriteLine(s.EndsWith("DOG", StringComparison.CurrentCulture))
+
    Console.WriteLine(s.EndsWith("DOG", StringComparison.CurrentCultureIgnoreCase))
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
+

          
+
#prompt{{
+
False
+
True
+
False
+
True
+
}}
+

          
+
***比較 (CompareTo, Equals, Compare)
+
&msdn(netfx,method,System.String.CompareTo){String.CompareToメソッド};と&msdn(netfx,method,System.String.Equals){String.Equalsメソッド};は文字列の比較を行うメソッドで、指定された文字列と比較した結果を返します。
+

          
+
CompareToメソッドの戻り値は、二つの文字列を並べ替えた時の順番に従い、次のようになります。 比較の際、null/Nothingは空文字を含むどのような文字列よりも'''小さい'''と判断され、null/Nothing同士は等価として扱われます。
+
|*String.CompareToの戻り値
+
|~文字列aとbの関係|~a.CompareTo(b)の戻り値|~例|h
+
|並べ替えたときにaの方がbよりも前&br;(aはbよりも'''小さい''')|0より小さい値|"ABC" < "ABD"&br;null < "ABC"|
+
|並べ替えたときにaとbは同じ位置&br;(aとbは'''等しい''')|0|"ABC" = "ABC"&br;null = null|
+
|並べ替えたときにaの方がbよりも後&br;(aはbよりも'''大きい''')|0より大きい値|"ABC" > "ABB"&br;"ABC" > null|
+

          
+
Equalsメソッドは、二つの文字列が等しい場合(CompareToメソッドが0を返す場合)にTrueを返します。
+

          
+
#tabpage(C#)
+
#code(cs){{
+
using System;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    string s1 = "foo";
+
    string s2 = "bar";
+
    string s3 = "baz";
+

          
+
    Console.WriteLine("{0} CompareTo {1} : {2}", s1, s2, s1.CompareTo(s2));
+
    Console.WriteLine("{0} CompareTo {1} : {2}", s1, s3, s1.CompareTo(s3));
+
    Console.WriteLine("{0} CompareTo {1} : {2}", s2, s3, s2.CompareTo(s3));
+
    Console.WriteLine("{0} CompareTo {1} : {2}", s2, s2, s2.CompareTo(s2));
+

          
+
    Console.WriteLine("{0} Equals {1} : {2}", s1, s2, s1.Equals(s2));
+
    Console.WriteLine("{0} Equals {1} : {2}", s1, s3, s1.Equals(s3));
+
    Console.WriteLine("{0} Equals {1} : {2}", s2, s3, s2.Equals(s3));
+
    Console.WriteLine("{0} Equals {1} : {2}", s2, s2, s2.Equals(s2));
+
  }
+
}
+
}}
+
#tabpage(VB)
+
#code(vb){{
+
Imports System
+

          
+
Class Sample
+
  Shared Sub Main()
+
    Dim s1 As String = "foo"
+
    Dim s2 As String = "bar"
+
    Dim s3 As String = "baz"
+

          
+
    Console.WriteLine("{0} CompareTo {1} : {2}", s1, s2, s1.CompareTo(s2))
+
    Console.WriteLine("{0} CompareTo {1} : {2}", s1, s3, s1.CompareTo(s3))
+
    Console.WriteLine("{0} CompareTo {1} : {2}", s2, s3, s2.CompareTo(s3))
+
    Console.WriteLine("{0} CompareTo {1} : {2}", s2, s2, s2.CompareTo(s2))
+

          
+
    Console.WriteLine("{0} Equals {1} : {2}", s1, s2, s1.Equals(s2))
+
    Console.WriteLine("{0} Equals {1} : {2}", s1, s3, s1.Equals(s3))
+
    Console.WriteLine("{0} Equals {1} : {2}", s2, s3, s2.Equals(s3))
+
    Console.WriteLine("{0} Equals {1} : {2}", s2, s2, s2.Equals(s2))
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
+

          
+
#prompt{{
+
foo CompareTo bar : 1
+
foo CompareTo baz : 1
+
bar CompareTo baz : -1
+
bar CompareTo bar : 0
+
foo Equals bar : False
+
foo Equals baz : False
+
bar Equals baz : False
+
bar Equals bar : True
+
}}
+

          
+
&msdn(netfx,method,System.String.Compare){String.Compareメソッド};は、CompareToメソッドと同じ動作をする静的メソッドです。 Equalsメソッドは、静的メソッドとしても用意されています。 戻り値はインスタンスメソッドの場合と同じです。
+

          
+
|*String.Compareの戻り値
+
|~文字列aとbの関係|~String.Compare(a, b)の戻り値|~例|h
+
|並べ替えたときにaの方がbよりも前&br;(aはbよりも'''小さい''')|0より小さい値|"ABC" < "ABD"&br;null < "ABC"|
+
|並べ替えたときにaとbは同じ位置&br;(aとbは'''等しい''')|0|"ABC" = "ABC"&br;null = null|
+
|並べ替えたときにaの方がbよりも後&br;(aはbよりも'''大きい''')|0より大きい値|"ABC" > "ABB"&br;"ABC" > null|
+

          
+
#tabpage(C#)
+
#code(cs){{
+
using System;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    string s1 = "foo";
+
    string s2 = "bar";
+
    string s3 = "baz";
+

          
+
    Console.WriteLine("Compare({0}, {1}) : {2}", s1, s2, String.Compare(s1, s2));
+
    Console.WriteLine("Compare({0}, {1}) : {2}", s1, s3, String.Compare(s1, s3));
+
    Console.WriteLine("Compare({0}, {1}) : {2}", s2, s3, String.Compare(s2, s3));
+
    Console.WriteLine("Compare({0}, {1}) : {2}", s2, s2, String.Compare(s2, s2));
+

          
+
    Console.WriteLine("Equals({0}, {1}) : {2}", s1, s2, String.Equals(s1, s2));
+
    Console.WriteLine("Equals({0}, {1}) : {2}", s1, s3, String.Equals(s1, s3));
+
    Console.WriteLine("Equals({0}, {1}) : {2}", s2, s3, String.Equals(s2, s3));
+
    Console.WriteLine("Equals({0}, {1}) : {2}", s2, s2, String.Equals(s2, s2));
+
  }
+
}
+
}}
+
#tabpage(VB)
+
#code(vb){{
+
Imports System
+

          
+
Class Sample
+
  Shared Sub Main()
+
    Dim s1 As String = "foo"
+
    Dim s2 As String = "bar"
+
    Dim s3 As String = "baz"
+

          
+
    Console.WriteLine("Compare({0}, {1}) : {2}", s1, s2, String.Compare(s1, s2))
+
    Console.WriteLine("Compare({0}, {1}) : {2}", s1, s3, String.Compare(s1, s3))
+
    Console.WriteLine("Compare({0}, {1}) : {2}", s2, s3, String.Compare(s2, s3))
+
    Console.WriteLine("Compare({0}, {1}) : {2}", s2, s2, String.Compare(s2, s2))
+

          
+
    Console.WriteLine("Equals({0}, {1}) : {2}", s1, s2, String.Equals(s1, s2))
+
    Console.WriteLine("Equals({0}, {1}) : {2}", s1, s3, String.Equals(s1, s3))
+
    Console.WriteLine("Equals({0}, {1}) : {2}", s2, s3, String.Equals(s2, s3))
+
    Console.WriteLine("Equals({0}, {1}) : {2}", s2, s2, String.Equals(s2, s2))
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
+

          
+
#prompt{{
+
Compare(foo, bar) : 1
+
Compare(foo, baz) : 1
+
Compare(bar, baz) : -1
+
Compare(bar, bar) : 0
+
Equals(foo, bar) : False
+
Equals(foo, baz) : False
+
Equals(bar, baz) : False
+
Equals(bar, bar) : True
+
}}
+

          
+
このように、インスタンスメソッドでも静的メソッドでも結果は同じですが、想定される状況により使い分けることが出来ます。 例えば、静的メソッドのCompareとEqualsを使うと、仮に文字列変数にnull/Nothingが代入されていてもヌル参照を引き起こさずに済みます。 (nullとの比較、null同士の比較を行っても例外エラーにはなりません)
+

          
+
#tabpage(C#)
+
#code(cs){{
+
using System;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    string s1 = null;
+
    string s2 = "foo";
+

          
+
    Console.WriteLine(String.Compare(s1, s2)); // エラーにはならない
+
    Console.WriteLine(s1.CompareTo(s2)); // NullReferenceExceptionがスローされる
+
  }
+
}
+
}}
+
#tabpage(VB)
+
#code(vb){{
+
Imports System
+

          
+
Class Sample
+
  Shared Sub Main()
+
    Dim s1 As String = Nothing
+
    Dim s2 As String = "foo"
+

          
+
    Console.WriteLine(String.Compare(s1, s2)) ' エラーにはならない
+
    Console.WriteLine(s1.CompareTo(s2)) ' NullReferenceExceptionがスローされる
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
+

          
+
CompareToメソッド、Compareメソッド、Equalsメソッドでは、文字列比較時のオプションを指定することができ、例えば大文字小文字の違いを無視した比較を行うことも出来ます。 文字列比較時のオプションについては[[StringComparisonとStringComparer>#StringComparisonStringComparer]]で詳しく説明します。
+

          
+
#tabpage(C#)
+
#code(cs){{
+
using System;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    string s1 = "Bar";
+
    string s2 = "bar";
+
    string s3 = "BAR";
+

          
+
    Console.WriteLine("Compare({0}, {1}) : {2}", s1, s2, String.Compare(s1, s2, StringComparison.CurrentCulture));
+
    Console.WriteLine("Compare({0}, {1}) : {2}", s1, s2, String.Compare(s1, s2, StringComparison.CurrentCultureIgnoreCase));
+
    Console.WriteLine("Compare({0}, {1}) : {2}", s1, s3, String.Compare(s1, s3, StringComparison.CurrentCulture));
+
    Console.WriteLine("Compare({0}, {1}) : {2}", s1, s3, String.Compare(s1, s3, StringComparison.CurrentCultureIgnoreCase));
+

          
+
    Console.WriteLine("Equals({0}, {1}) : {2}", s1, s2, String.Equals(s1, s2, StringComparison.CurrentCulture));
+
    Console.WriteLine("Equals({0}, {1}) : {2}", s1, s2, String.Equals(s1, s2, StringComparison.CurrentCultureIgnoreCase));
+
    Console.WriteLine("Equals({0}, {1}) : {2}", s1, s3, String.Equals(s1, s3, StringComparison.CurrentCulture));
+
    Console.WriteLine("Equals({0}, {1}) : {2}", s1, s3, String.Equals(s1, s3, StringComparison.CurrentCultureIgnoreCase));
+

          
+
  }
+
}
+
}}
+
#tabpage(VB)
+
#code(vb){{
+
Imports System
+

          
+
Class Sample
+
  Shared Sub Main()
+
    Dim s1 As String = "Bar"
+
    Dim s2 As String = "bar"
+
    Dim s3 As String = "BAR"
+

          
+
    Console.WriteLine("Compare({0}, {1}) : {2}", s1, s2, String.Compare(s1, s2, StringComparison.CurrentCulture))
+
    Console.WriteLine("Compare({0}, {1}) : {2}", s1, s2, String.Compare(s1, s2, StringComparison.CurrentCultureIgnoreCase))
+
    Console.WriteLine("Compare({0}, {1}) : {2}", s1, s3, String.Compare(s1, s3, StringComparison.CurrentCulture))
+
    Console.WriteLine("Compare({0}, {1}) : {2}", s1, s3, String.Compare(s1, s3, StringComparison.CurrentCultureIgnoreCase))
+

          
+
    Console.WriteLine("Equals({0}, {1}) : {2}", s1, s2, String.Equals(s1, s2, StringComparison.CurrentCulture))
+
    Console.WriteLine("Equals({0}, {1}) : {2}", s1, s2, String.Equals(s1, s2, StringComparison.CurrentCultureIgnoreCase))
+
    Console.WriteLine("Equals({0}, {1}) : {2}", s1, s3, String.Equals(s1, s3, StringComparison.CurrentCulture))
+
    Console.WriteLine("Equals({0}, {1}) : {2}", s1, s3, String.Equals(s1, s3, StringComparison.CurrentCultureIgnoreCase))
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
+

          
+
#prompt{{
+
Compare(Bar, bar) : 1
+
Compare(Bar, bar) : 0
+
Compare(Bar, BAR) : -1
+
Compare(Bar, BAR) : 0
+
Equals(Bar, bar) : False
+
Equals(Bar, bar) : True
+
Equals(Bar, BAR) : False
+
Equals(Bar, BAR) : True
+
}}
+

          
+
***序数による比較 (CompareOrdinal)
+
&msdn(netfx,method,System.String.CompareOrdinal){String.CompareOrdinalメソッド};はCompareメソッド同様、文字列の比較を行う静的メソッドですが、Compareメソッドが現在のスレッドの(もしくは引数で指定された)カルチャの規則にしたがった比較を行うのに対し、CompareOrdinalメソッドではカルチャに依存せず、比較の際には文字列の各文字を数値(Unicode序数、Unicode ordinal)、つまりコードポイントで比較します。
+

          
+
#tabpage(C#)
+
#code(cs){{
+
using System;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    string[] p1 = new string[] {"abc", "abd"};
+
    string[] p2 = new string[] {"coop", "co-op"};
+
    string[] p3 = new string[] {"cant", "can't"};
+

          
+
    Console.WriteLine("Compare       ({0}, {1}) : {2}", p1[0], p1[1], String.Compare(p1[0], p1[1]));
+
    Console.WriteLine("CompareOrdinal({0}, {1}) : {2}", p1[0], p1[1], String.CompareOrdinal(p1[0], p1[1]));
+

          
+
    Console.WriteLine("Compare       ({0}, {1}) : {2}", p2[0], p2[1], String.Compare(p2[0], p2[1]));
+
    Console.WriteLine("CompareOrdinal({0}, {1}) : {2}", p2[0], p2[1], String.CompareOrdinal(p2[0], p2[1]));
+

          
+
    Console.WriteLine("Compare       ({0}, {1}) : {2}", p3[0], p3[1], String.Compare(p3[0], p3[1]));
+
    Console.WriteLine("CompareOrdinal({0}, {1}) : {2}", p3[0], p3[1], String.CompareOrdinal(p3[0], p3[1]));
+
  }
+
}
+
}}
+
#tabpage(VB)
+
#code(vb){{
+
Imports System
+

          
+
Class Sample
+
  Shared Sub Main()
+
    Dim p1 As String() = New String() {"abc", "abd"}
+
    Dim p2 As String() = New String() {"coop", "co-op"}
+
    Dim p3 As String() = New String() {"cant", "can't"}
+

          
+
    Console.WriteLine("Compare       ({0}, {1}) : {2}", p1(0), p1(1), String.Compare(p1(0), p1(1)))
+
    Console.WriteLine("CompareOrdinal({0}, {1}) : {2}", p1(0), p1(1), String.CompareOrdinal(p1(0), p1(1)))
+

          
+
    Console.WriteLine("Compare       ({0}, {1}) : {2}", p2(0), p2(1), String.Compare(p2(0), p2(1)))
+
    Console.WriteLine("CompareOrdinal({0}, {1}) : {2}", p2(0), p2(1), String.CompareOrdinal(p2(0), p2(1)))
+

          
+
    Console.WriteLine("Compare       ({0}, {1}) : {2}", p3(0), p3(1), String.Compare(p3(0), p3(1)))
+
    Console.WriteLine("CompareOrdinal({0}, {1}) : {2}", p3(0), p3(1), String.CompareOrdinal(p3(0), p3(1)))
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
+

          
+
#prompt{{
+
Compare       (abc, abd) : -1
+
CompareOrdinal(abc, abd) : -1
+
Compare       (coop, co-op) : -1
+
CompareOrdinal(coop, co-op) : 66
+
Compare       (cant, can't) : -1
+
CompareOrdinal(cant, can't) : 77
+
}}
+

          
+
CompareメソッドとCompareOrdinalメソッドで大小関係が反転している箇所に注目してください。 他のメソッドでも、CompareOrdinalと同様の比較方法を使用するように指定できます。 これについては[[StringComparisonとStringComparer>#StringComparisonStringComparer]]で詳しく説明します。
+

          
+
***等価演算子(==, !=, <>)
+
C#、VB.NETでは等価演算子・不等価演算子を用いることでEqualsメソッドと同等の比較が行えます。 C#、VB.NETでのstring同士の等価演算子の結果は、String.Equals(a, b)と同じ動作となります。 不等価演算子は、String.Equals(a, b)の結果を否定(反転)したものと同じです。
+

          
+
#tabpage(C#)
+
#code(cs){{
+
using System;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    string s1 = "foo";
+
    string s2 = "bar";
+
    string s3 = "foo";
+

          
+
    Console.WriteLine("{0} == {1}: {2}", s1, s2, s1 == s2);
+
    Console.WriteLine("{0} != {1}: {2}", s1, s2, s1 != s2);
+
    Console.WriteLine("{0} == {1}: {2}", s1, s3, s1 == s3);
+
    Console.WriteLine("{0} != {1}: {2}", s1, s3, s1 != s3);
+
  }
+
}
+
}}
+
#tabpage(VB)
+
#code(vb){{
+
Imports System
+

          
+
Class Sample
+
  Shared Sub Main()
+
    Dim s1 As String = "foo"
+
    Dim s2 As String = "bar"
+
    Dim s3 As String = "foo"
+

          
+
    Console.WriteLine("{0} = {1}:  {2}", s1, s2, s1 = s2)
+
    Console.WriteLine("{0} <> {1}: {2}", s1, s2, s1 <> s2)
+
    Console.WriteLine("{0} = {1}:  {2}", s1, s3, s1 = s3)
+
    Console.WriteLine("{0} <> {1}: {2}", s1, s3, s1 <> s3)
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
+

          
+
#prompt{{
+
foo == bar: False
+
foo != bar: True
+
foo == foo: True
+
foo != foo: False
+
}}
+

          
+
当然ながら、等価演算子・不等価演算子による比較の場合は、カルチャを無視したり大文字小文字を無視したりといった文字列比較時のオプション([[StringComparison>#StringComparison]])を指定することはできません。 そういった場合は、Equalsメソッドを用いる必要があります。
+

          
+
また、C#において、等価演算子・不等価演算子がオーバーロードされていない限り、両辺がstringでないとコンパイルエラーとなります(タイプセーフ)。 Equalsメソッドは、引数にObject型をとるオーバーロードも用意されているため、string同士以外でもコンパイルエラーとはなりません。 等価演算子とEqualsメソッドではパフォーマンスに若干の違いはありますが、どちらを使うのが妥当かは状況により異なるので、両者の違いを十分に考慮して選択する必要があります。
+

          
+
#code(cs){{
+
using System;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    string s = "16";
+
    int i = 16;
+

          
+
    // Console.WriteLine(s == i); // stringとintでは等価演算子による比較は出来ない
+
    Console.WriteLine(String.Equals(s, i)); // Equalsメソッドでは、stringとintでも比較は出来る
+
  }
+
}
+
}}
+

          
+
***比較演算子 (<, <=, >, >=, Like)
+
(このドキュメントは未整理です)
+

          
+
VB.NETでは、不等号演算子、Like演算子を用いることでCompareメソッドと同等の比較が行えます。 比較時の動作は、&msdn(netfx,id,8t3khw5f){Option Compareステートメント};の設定により変わります。
+

          
+
C#では、不等号演算子による文字列の比較は行えないので、Compareメソッドを使用する必要があります。
+

          
+
**Stringクラスで提供されない操作
+
ここではStringクラスで提供されない文字列操作と、それを実装する例を見ていきます。 以下の例では引数のチェック等は省略しています。
+

          
+
***部分文字列の計上 (Count)
+
Stringクラスでは文字列中に含まれる部分文字列の数を計上するメソッドは用意されていません。 以下は部分文字列の計上を行う例です。 Count1ではIndexOfメソッドを用いて部分文字列の検索を繰り返すことで数を計上しています。 Count2ではReplaceメソッドを用いて部分文字列を削除し、減った文字数をもとに計上しています。
+

          
+
#tabpage(C#)
+
#code(cs){{
+
using System;
+

          
+
class Sample
+
{
+
  static int Count1(string s, string substr)
+
  {
+
    for (int count = 0, lastIndex = 0;; count++)
+
    {
+
      int index = s.IndexOf(substr, lastIndex);
+

          
+
      if (index < 0)
+
      {
+
        return count;
+
      }
+
      else
+
      {
+
        lastIndex = index + substr.Length;
+
      }
+
    }
+
  }
+

          
+
  static int Count2(string s, string substr)
+
  {
+
    return (s.Length - s.Replace(substr, null).Length) / substr.Length;
+
  }
+

          
+
  static void Main()
+
  {
+
    string s = "かごめかごめ かごのなかのとりは いついつでやる";
+

          
+
    Console.WriteLine(s);
+
    Console.WriteLine(Count1(s, "かご"));
+
    Console.WriteLine(Count2(s, "かご"));
+
    Console.WriteLine(Count1(s, "いつ"));
+
    Console.WriteLine(Count2(s, "いつ"));
+
    Console.WriteLine(Count1(s, "か"));
+
    Console.WriteLine(Count2(s, "か"));
+
  }
+
}
+
}}
+
#tabpage(VB)
+
#code(vb){{
+
Imports System
+

          
+
Class Sample
+
  Shared Function Count1(ByVal s As String, ByVal substr As String) As Integer
+
    Dim count As Integer = 0
+
    Dim lastIndex As Integer = 0
+

          
+
    Do
+
      Dim index As Integer = s.IndexOf(substr, lastIndex)
+

          
+
      If index < 0 Then
+
        Return count
+
      Else
+
        count += 1
+
        lastIndex = index + substr.Length
+
      End If
+
    Loop
+
  End Function
+

          
+
  Shared Function Count2(ByVal s As String, ByVal substr As String) As Integer
+
    Return (s.Length - s.Replace(substr, Nothing).Length) \ substr.Length
+
  End Function
+

          
+
  Shared Sub Main()
+
    Dim s As String = "かごめかごめ かごのなかのとりは いついつでやる"
+

          
+
    Console.WriteLine(s)
+
    Console.WriteLine(Count1(s, "かご"))
+
    Console.WriteLine(Count2(s, "かご"))
+
    Console.WriteLine(Count1(s, "いつ"))
+
    Console.WriteLine(Count2(s, "いつ"))
+
    Console.WriteLine(Count1(s, "か"))
+
    Console.WriteLine(Count2(s, "か"))
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
+

          
+
#prompt{{
+
かごめかごめ かごのなかのとりは いついつでやる
+
3
+
3
+
2
+
2
+
4
+
4
+
}}
+

          
+
***反転 (Reverse)
+
Stringクラスでは文字列の並びを反転するメソッドは用意されていません。 以下は文字列の反転を行う例です。 ToCharArrayメソッドを用いて一度Char配列にしてから、Array.Reverseメソッドにより反転したのちに再びStringに変換することで文字列の反転を実現しています。
+

          
+
#tabpage(C#)
+
#code(cs){{
+
using System;
+

          
+
class Sample
+
{
+
  static string Reverse(string s)
+
  {
+
    char[] chars = s.ToCharArray();
+

          
+
    Array.Reverse(chars);
+

          
+
    return new string(chars);
+
  }
+

          
+
  static void Main()
+
  {
+
    string s1 = "The quick brown fox jumps over the lazy dog";
+
    string s2 = "かごめかごめ かごのなかのとりは いついつでやる";
+

          
+
    Console.WriteLine(s1);
+
    Console.WriteLine(Reverse(s1));
+

          
+
    Console.WriteLine(s2);
+
    Console.WriteLine(Reverse(s2));
+
  }
+
}
+
}}
+
#tabpage(VB)
+
#code(vb){{
+
Imports System
+

          
+
Class Sample
+
  Shared Function Reverse(ByVal s As String) As String
+
    Dim chars As Char() = s.ToCharArray()
+

          
+
    Array.Reverse(chars)
+

          
+
    Return New String(chars)
+
  End Function
+

          
+
  Shared Sub Main()
+
    Dim s1 As String = "The quick brown fox jumps over the lazy dog"
+
    Dim s2 As String = "かごめかごめ かごのなかのとりは いついつでやる"
+

          
+
    Console.WriteLine(s1)
+
    Console.WriteLine(Reverse(s1))
+

          
+
    Console.WriteLine(s2)
+
    Console.WriteLine(Reverse(s2))
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
+

          
+
#prompt{{
+
The quick brown fox jumps over the lazy dog
+
god yzal eht revo spmuj xof nworb kciuq ehT
+
かごめかごめ かごのなかのとりは いついつでやる
+
るやでついつい はりとのかなのごか めごかめごか
+
}}
+

          
+
***センタリング
+
StringクラスではPadLeftによる左詰め、PadRightによる右詰めは行えますが、文字列の中寄せ(センタリング)を行うメソッドは用意されていません。 以下は文字列のセンタリングを行う例です。 指定された幅で文字列が中央に来るよう左右に空白を入れています。 文字数よりも幅が下回る場合はそのままにします。
+

          
+
#tabpage(C#)
+
#code(cs){{
+
using System;
+

          
+
class Sample
+
{
+
  static string Center(string s, int width)
+
  {
+
    int margin = (width - s.Length) / 2;
+

          
+
    if (margin <= 0)
+
    {
+
      return s;
+
    }
+
    else
+
    {
+
      string padding = new String(' ', margin);
+

          
+
      return String.Concat(padding, s, padding);
+
    }
+
  }
+

          
+
  static void Main()
+
  {
+
    string s = "foo";
+

          
+
    Console.WriteLine("<{0}>", Center(s, 5));
+
    Console.WriteLine("<{0}>", Center(s, 6));
+
    Console.WriteLine("<{0}>", Center(s, 10));
+
    Console.WriteLine("<{0}>", Center(s, 20));
+
    Console.WriteLine("<{0}>", Center(s, 0));
+
  }
+
}
+
}}
+
#tabpage(VB)
+
#code(vb){{
+
Imports System
+

          
+
Class Sample
+
  Shared Function Center(ByVal s As String, ByVal width As Integer) As String
+
    Dim margin As Integer = (width - s.Length) \ 2
+

          
+
    If margin <= 0 Then
+
      Return s
+
    Else
+
      Dim padding As New String(" "c, margin)
+

          
+
      Return String.Concat(padding, s, padding)
+
    End If
+
  End Function
+

          
+
  Shared Sub Main()
+
    Dim s As String = "foo"
+

          
+
    Console.WriteLine("<{0}>", Center(s, 5))
+
    Console.WriteLine("<{0}>", Center(s, 6))
+
    Console.WriteLine("<{0}>", Center(s, 10))
+
    Console.WriteLine("<{0}>", Center(s, 20))
+
    Console.WriteLine("<{0}>", Center(s, 0))
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
+

          
+
#prompt{{
+
< foo >
+
< foo >
+
<   foo   >
+
<        foo        >
+
<foo>
+
}}
+

          
+
***乗算演算子 (*, *=)
+
Stringクラスでは乗算演算子はサポートされていません。 いくつかの言語では乗算演算子を使って同じ文字の並びを任意の回数だけ繰り替えした文字列を作ることが出来ますが、Stringクラスではそういった操作は用意されていません。 そのため、必要な回数だけ連結を繰り返す必要があります。
+

          
+
#tabpage(C#)
+
#code(cs){{
+
using System;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    // string s = "foo" * 10;
+
    string s = string.Empty;
+

          
+
    for (int i = 0; i < 10; i++)
+
    {
+
      s += "foo";
+
    }
+

          
+
    Console.WriteLine(s);
+
  }
+
}
+
}}
+
#tabpage(VB)
+
#code(vb){{
+
Imports System
+

          
+
Class Sample
+
  Shared Sub Main()
+
    ' Dim s As String = "foo" * 10
+
    Dim s As String = String.Empty
+

          
+
    For i As Integer = 1 To 10
+
      s += "foo"
+
    Next
+

          
+
    Console.WriteLine(s)
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
+

          
+
なお、Stringクラスのコンストラクタを使うことで、同じ文字を任意の回数だけ繰り替えした文字を作ることは出来ます。
+

          
+
#tabpage(C#)
+
#code(cs){{
+
using System;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    string s = new string('あ', 10);
+

          
+
    Console.WriteLine(s);
+
  }
+
}
+
}}
+
#tabpage(VB)
+
#code(vb){{
+
Imports System
+

          
+
Class Sample
+
  Shared Sub Main()
+
    Dim s As New String("あ"c, 10)
+

          
+
    Console.WriteLine(s)
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
+

          
+
#prompt{{
+
ああああああああああ
+
}}
+

          
+
**VBの文字列操作関数
+
(このドキュメントは未整理です)
+

          
+
あまり推奨は出来ませんが、Microsoft.VisualBasic名前空間の&msdn(netfx,type,Microsoft.VisualBasic.Strings){Stringsクラス};のメソッドを使うことで、VB由来の文字列操作関数を使うことも出来ます。 VB.NETでもこれらの関数を使うことは出来ますが、新規に書くコードではできるだけStringクラスのメソッドを使うべきです。 これらの文字列操作関数ではインデックスが1から始まる(1-based)として扱われる一方、.NET Frameworkでは0から始まる(0-based)として扱われるため、混乱を招いたり意図しない動作となる可能性があります。
+

          
+
#code(cs){{
+
using System;
+
using Microsoft.VisualBasic;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    Console.WriteLine("<{0}>", Strings.LTrim("   foo"));
+
    Console.WriteLine("<{0}>", Strings.RTrim("foo   "));
+
    Console.WriteLine(Strings.UCase("foo"));
+
    Console.WriteLine(Strings.LCase("FOO"));
+
    Console.WriteLine(Strings.Mid("The quick brown fox jumps over the lazy dog", 1, 9)); // '1'文字目から9文字分を取得する
+
    Console.WriteLine("The quick brown fox jumps over the lazy dog".Substring(0, 9)); // '0'文字目から9文字分を取得する
+
    Console.WriteLine(Strings.InStr("The quick brown fox", "FOX", CompareMethod.Binary));
+
    Console.WriteLine(Strings.InStr("The quick brown fox", "FOX", CompareMethod.Text));
+
    Console.WriteLine("The quick brown fox".IndexOf("FOX"));
+
    Console.WriteLine("The quick brown fox".IndexOf("FOX", StringComparison.CurrentCultureIgnoreCase));
+
  }
+
}
+
}}
+

          
+
#prompt{{
+
<foo>
+
<foo>
+
FOO
+
foo
+
The quick
+
The quick
+
0
+
17
+
-1
+
16
+
}}
+

          
+
----
+

          
+
*&aname(StringComparisonStringComparer){StringComparison列挙型とStringComparerクラス};
+
.NET Frameworkでは、文字列比較の際の動作を指定することができます。 単純な比較のほか、大文字小文字の無視、特定カルチャに依存した並べ替え規則の適用などを状況に応じて選択できます。
+

          
+
**&aname(StringComparison){StringComparison列挙型};
+
&msdn(netfx,type,System.StringComparison){StringComparison列挙型};は、文字列比較の際の動作を指定するための列挙型で、次のメソッドにおいて文字列比較を行う際にオプションとして指定出来ます。
+

          
+
-StringComparisonを引数にとるメソッド
+
--&msdn(netfx,method,System.String.Compare){String.Compareメソッド};
+
--&msdn(netfx,method,System.String.Equals){String.Equalsメソッド};
+
--&msdn(netfx,method,System.String.IndexOf){String.IndexOfメソッド};
+
--&msdn(netfx,method,System.String.LastIndexOf){String.LastIndexOfメソッド};
+
--&msdn(netfx,method,System.String.StartsWith){String.StartsWithメソッド};
+
--&msdn(netfx,method,System.String.EndsWith){String.EndsWithメソッド};
+

          
+
また、StringComparisonを指定する場合は、次のいずれかを指定できます。
+
|*StringComparison
+
|~StringComparisonの値|~文字列比較時の動作|h
+
|StringComparison.CurrentCulture|現在のカルチャの並べ替え規則に基づいて比較する&br;(StringComparisonを指定しない場合はこの動作になります)|
+
|StringComparison.CurrentCultureIgnoreCase|現在のカルチャの並べ替え規則に基づいて比較する&br;大文字小文字の違いは無視する|
+
|StringComparison.InvariantCulture|インバリアントカルチャの並べ替え規則に基づいて比較する|
+
|StringComparison.InvariantCultureIgnoreCase|インバリアントカルチャの並べ替え規則に基づいて比較する&br;大文字小文字の違いは無視する|
+
|StringComparison.Ordinal|文字列の各文字を数値(Unicode序数、Unicode ordinal)=コードポイントで比較する|
+
|StringComparison.OrdinalIgnoreCase|文字列の各文字を数値(Unicode序数、Unicode ordinal)=コードポイントで比較する&br;大文字小文字の違いは無視する|
+

          
+
以下はStringComparisonを指定して比較を行う例です。
+

          
+
#tabpage(C#)
+
#code(cs){{
+
using System;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    string s1 = "foo";
+
    string s2 = "FOO";
+

          
+
    // 以下の2つは同じ
+
    Console.WriteLine(s1.Equals(s2));
+
    Console.WriteLine(s1.Equals(s2, StringComparison.CurrentCulture));
+

          
+
    // 以下の2つは同じ
+
    Console.WriteLine(String.Equals(s1, s2));
+
    Console.WriteLine(String.Equals(s1, s2, StringComparison.CurrentCulture));
+

          
+
    // 以下の2つは同じ
+
    Console.WriteLine(String.Compare(s1, s2));
+
    Console.WriteLine(String.Compare(s1, s2, StringComparison.CurrentCulture));
+

          
+
    Console.WriteLine("[IgnoreCase]");
+

          
+
    // 大文字小文字を無視する/しない比較
+
    Console.WriteLine(String.Equals(s1, s2, StringComparison.CurrentCultureIgnoreCase));
+
    Console.WriteLine(String.Equals(s1, s2, StringComparison.CurrentCulture));
+

          
+
    Console.WriteLine(String.Compare(s1, s2, StringComparison.CurrentCultureIgnoreCase));
+
    Console.WriteLine(String.Compare(s1, s2, StringComparison.CurrentCulture));
+
  }
+
}
+
}}
+
#tabpage(VB)
+
#code(vb){{
+
Imports System
+

          
+
Class Sample
+
  Shared Sub Main()
+
    Dim s1 As String = "foo"
+
    Dim s2 As String = "FOO"
+

          
+
    ' 以下の2つは同じ
+
    Console.WriteLine(s1.Equals(s2))
+
    Console.WriteLine(s1.Equals(s2, StringComparison.CurrentCulture))
+

          
+
    ' 以下の2つは同じ
+
    Console.WriteLine(String.Equals(s1, s2))
+
    Console.WriteLine(String.Equals(s1, s2, StringComparison.CurrentCulture))
+

          
+
    ' 以下の2つは同じ
+
    Console.WriteLine(String.Compare(s1, s2))
+
    Console.WriteLine(String.Compare(s1, s2, StringComparison.CurrentCulture))
+

          
+
    Console.WriteLine("[IgnoreCase]")
+

          
+
    ' 大文字小文字を無視する/しない比較
+
    Console.WriteLine(String.Equals(s1, s2, StringComparison.CurrentCultureIgnoreCase))
+
    Console.WriteLine(String.Equals(s1, s2, StringComparison.CurrentCulture))
+

          
+
    Console.WriteLine(String.Compare(s1, s2, StringComparison.CurrentCultureIgnoreCase))
+
    Console.WriteLine(String.Compare(s1, s2, StringComparison.CurrentCulture))
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
+

          
+
#prompt{{
+
False
+
False
+
False
+
False
+
-1
+
-1
+
[IgnoreCase]
+
True
+
False
+
0
+
-1
+
}}
+

          
+
***CurrentCulture(IgnoreCase)とInvariantCulture(IgnoreCase)の違い
+
CurrentCulture(IgnoreCase)とInvariantCulture(IgnoreCase)は、特定のカルチャでの規則に基づいた比較を行う点では同じですが、CurrentCulture(IgnoreCase)では現在のカルチャに基づいた比較を行うのに対し、InvariantCulture(IgnoreCase)ではインバリアントカルチャ(特定の文化圏や言語に依存しない)に基づいた比較を行う点が異なります。
+

          
+
以下はString.Compareメソッドの結果を用いてこれらの違いを見るためのサンプルです。
+

          
+
#tabpage(C#)
+
#code(cs){{
+
using System;
+
using System.Globalization;
+
using System.Threading;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    Console.WriteLine(Thread.CurrentThread.CurrentCulture);
+

          
+
    Console.WriteLine("Compare CurrentCulture   : {0}", String.Compare("亜", "井", StringComparison.CurrentCulture));
+
    Console.WriteLine("Compare InvariantCulture : {0}", String.Compare("亜", "井", StringComparison.InvariantCulture));
+

          
+
    // 現在のスレッドのカルチャをen-US(英語/米国)に変更
+
    Thread.CurrentThread.CurrentCulture = CultureInfo.GetCultureInfo("en-US");
+

          
+
    Console.WriteLine(Thread.CurrentThread.CurrentCulture);
+

          
+
    Console.WriteLine("Compare CurrentCulture   : {0}", String.Compare("亜", "井", StringComparison.CurrentCulture));
+
    Console.WriteLine("Compare InvariantCulture : {0}", String.Compare("亜", "井", StringComparison.InvariantCulture));
+
  }
+
}
+
}}
+
#tabpage(VB)
+
#code(vb){{
+
Imports System
+
Imports System.Globalization
+
Imports System.Threading
+

          
+
Class Sample
+
  Shared Sub Main()
+
    Console.WriteLine(Thread.CurrentThread.CurrentCulture)
+

          
+
    Console.WriteLine("Compare CurrentCulture   : {0}", String.Compare("亜", "井", StringComparison.CurrentCulture))
+
    Console.WriteLine("Compare InvariantCulture : {0}", String.Compare("亜", "井", StringComparison.InvariantCulture))
+

          
+
    ' 現在のスレッドのカルチャをen-US(英語/米国)に変更
+
    Thread.CurrentThread.CurrentCulture = CultureInfo.GetCultureInfo("en-US")
+

          
+
    Console.WriteLine(Thread.CurrentThread.CurrentCulture)
+

          
+
    Console.WriteLine("Compare CurrentCulture   : {0}", String.Compare("亜", "井", StringComparison.CurrentCulture))
+
    Console.WriteLine("Compare InvariantCulture : {0}", String.Compare("亜", "井", StringComparison.InvariantCulture))
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
+

          
+
#prompt{{
+
ja-JP
+
Compare CurrentCulture   : -1
+
Compare InvariantCulture : 1
+
en-US
+
Compare CurrentCulture   : 1
+
Compare InvariantCulture : 1
+
}}
+

          
+
スレッドのカルチャをen-US(英語/米国)に変更する前後の結果に注目してください。 InvariantCultureでの結果はどちらも変わらないのに対し、CurrentCultureでの結果は、スレッドのカルチャを変更する前後で異なっています。
+

          
+
これは、ja-JP(日本語/日本)の規則では漢字の読みによる並びとなっているために''亜''(あ)の方が''井''(い)より小さい(前に並ぶ)、つまり"''亜''<''井''"とされるのに対し、en-US(英語/米国)の規則では文字のコードポイントによる並びとなっているために''井''(U+4E95)の方が''亜''(U+4E9C)よりも小さい(前に並ぶ)、つまり"''亜''>''井''"とされるためです。 そのため、CurrentCultureによる比較の結果は、ja-JPとen-USにより異なります。 一方、InvariantCultureの場合は特定の言語に依存しない規則に基づいて比較されるため、ja-JPでもen-USでも''井''の方が''亜''よりも小さいというどちらも同じ結果となります。 (参考: &msdn(netfx,id,a7zyyk0c){固有カルチャのデータの比較と並べ替え};)
+

          
+
続いて、CurrentCultureIgnoreCaseとInvariantCultureIgnoreCaseでも違いが現れる例を見てみます。
+

          
+
#tabpage(C#)
+
#code(cs){{
+
using System;
+
using System.Globalization;
+
using System.Threading;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    Console.WriteLine(Thread.CurrentThread.CurrentCulture);
+

          
+
    Console.WriteLine("Compare CurrentCulture             : {0}", String.Compare("i", "I", StringComparison.CurrentCulture));
+
    Console.WriteLine("Compare CurrentCultureIgnoreCase   : {0}", String.Compare("i", "I", StringComparison.CurrentCultureIgnoreCase));
+
    Console.WriteLine("Compare InvariantCulture           : {0}", String.Compare("i", "I", StringComparison.InvariantCulture));
+
    Console.WriteLine("Compare InvariantCultureIgnoreCase : {0}", String.Compare("i", "I", StringComparison.InvariantCultureIgnoreCase));
+

          
+
    Console.WriteLine("{0} => {1}", "i", "i".ToUpper());
+
    Console.WriteLine("{0} => {1}", "I", "I".ToLower());
+

          
+
    // 現在のスレッドのカルチャをtr-TR(トルコ語/トルコ)に変更
+
    Thread.CurrentThread.CurrentCulture = CultureInfo.GetCultureInfo("tr-TR");
+

          
+
    Console.WriteLine(Thread.CurrentThread.CurrentCulture);
+

          
+
    Console.WriteLine("Compare CurrentCulture             : {0}", String.Compare("i", "I", StringComparison.CurrentCulture));
+
    Console.WriteLine("Compare CurrentCultureIgnoreCase   : {0}", String.Compare("i", "I", StringComparison.CurrentCultureIgnoreCase));
+
    Console.WriteLine("Compare InvariantCulture           : {0}", String.Compare("i", "I", StringComparison.InvariantCulture));
+
    Console.WriteLine("Compare InvariantCultureIgnoreCase : {0}", String.Compare("i", "I", StringComparison.InvariantCultureIgnoreCase));
+

          
+
    Console.WriteLine("{0} => {1}", "i", "i".ToUpper());
+
    Console.WriteLine("{0} => {1}", "I", "I".ToLower());
+
  }
+
}
+
}}
+
#tabpage(VB)
+
#code(vb){{
+
Imports System
+
Imports System.Globalization
+
Imports System.Threading
+

          
+
Class Sample
+
  Shared Sub Main()
+
    Console.WriteLine(Thread.CurrentThread.CurrentCulture)
+

          
+
    Console.WriteLine("Compare CurrentCulture             : {0}", String.Compare("i", "I", StringComparison.CurrentCulture))
+
    Console.WriteLine("Compare CurrentCultureIgnoreCase   : {0}", String.Compare("i", "I", StringComparison.CurrentCultureIgnoreCase))
+
    Console.WriteLine("Compare InvariantCulture           : {0}", String.Compare("i", "I", StringComparison.InvariantCulture))
+
    Console.WriteLine("Compare InvariantCultureIgnoreCase : {0}", String.Compare("i", "I", StringComparison.InvariantCultureIgnoreCase))
+

          
+
    Console.WriteLine("{0} => {1}", "i", "i".ToUpper())
+
    Console.WriteLine("{0} => {1}", "I", "I".ToLower())
+

          
+
    ' 現在のスレッドのカルチャをtr-TR(トルコ語/トルコ)に変更
+
    Thread.CurrentThread.CurrentCulture = CultureInfo.GetCultureInfo("tr-TR")
+

          
+
    Console.WriteLine(Thread.CurrentThread.CurrentCulture)
+

          
+
    Console.WriteLine("Compare CurrentCulture             : {0}", String.Compare("i", "I", StringComparison.CurrentCulture))
+
    Console.WriteLine("Compare CurrentCultureIgnoreCase   : {0}", String.Compare("i", "I", StringComparison.CurrentCultureIgnoreCase))
+
    Console.WriteLine("Compare InvariantCulture           : {0}", String.Compare("i", "I", StringComparison.InvariantCulture))
+
    Console.WriteLine("Compare InvariantCultureIgnoreCase : {0}", String.Compare("i", "I", StringComparison.InvariantCultureIgnoreCase))
+

          
+
    Console.WriteLine("{0} => {1}", "i", "i".ToUpper())
+
    Console.WriteLine("{0} => {1}", "I", "I".ToLower())
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
+

          
+
#prompt{{
+
ja-JP
+
Compare CurrentCulture             : -1
+
Compare CurrentCultureIgnoreCase   : 0
+
Compare InvariantCulture           : -1
+
Compare InvariantCultureIgnoreCase : 0
+
i => I
+
I => i
+
tr-TR
+
Compare CurrentCulture             : 1
+
Compare CurrentCultureIgnoreCase   : 1
+
Compare InvariantCulture           : -1
+
Compare InvariantCultureIgnoreCase : 0
+
i => İ
+
I => ı
+
}}
+

          
+
トルコ語においては、''i''(U+0069)と''I''(U+0049)は大文字小文字の関係にある同じ文字ではなくそれぞれ発音の異なる文字であり、''i''の大文字は''I''(U+0049)ではなく''İ''(U+0131)で、''I''の小文字は''i''(U+0069)ではなく''ı''(U+0130)となります。
+

          
+
そのため、ja-JP(日本語/日本)の場合はCurrentCultureIgnoreCaseで大文字小文字を無視すると''i''(U+0069)と''I''(U+0049)は同じ文字として扱われ、tr-TR(トルコ語/トルコ)では''i''と''I''は大文字小文字を無視しても異なる文字として扱われます。 一方InvariantCultureIgnoreCaseの場合は、特定の言語に依存しない規則に基づいて比較されるため、ja-JPでもtr-TRでも大文字小文字を無視すると''i''(U+0069)と''I''(U+0049)は同じ文字として扱われます。
+

          
+
このように、特定の言語や文化圏に依存した規則に基づいて比較を行いたい場合はCurrentCulture(IgnoreCase)、特定の言語や文化圏に依存しない規則に基づいて比較を行いたい場合はInvariantCulture(IgnoreCase)を使用する必要があります。
+

          
+
***CurrentCulture(IgnoreCase)とOrdinal(IgnoreCase)の違い
+
CurrentCulture(IgnoreCase)とInvariantCulture(IgnoreCase)は、特定のカルチャでの規則に基づいて比較をいますが、Ordinal(IgnoreCase)ではカルチャの依存せず、文字列の各文字を数値(Unicode序数、Unicode ordinal)、つまりコードポイントで比較します。
+

          
+
#tabpage(C#)
+
#code(cs){{
+
using System;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    Console.WriteLine("Compare CurrentCulture : {0}", String.Compare("亜", "井", StringComparison.CurrentCulture));
+
    Console.WriteLine("Compare Ordnal         : {0}", String.Compare("亜", "井", StringComparison.Ordinal));
+
  }
+
}
+
}}
+
#tabpage(VB)
+
#code(vb){{
+
Imports System
+

          
+
Class Sample
+
  Shared Sub Main()
+
    Console.WriteLine("Compare CurrentCulture : {0}", String.Compare("亜", "井", StringComparison.CurrentCulture))
+
    Console.WriteLine("Compare Ordnal         : {0}", String.Compare("亜", "井", StringComparison.Ordinal))
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
+

          
+
#prompt{{
+
Compare CurrentCulture : -1
+
Compare Ordnal         : 7
+
}}
+

          
+
CurrentCultureとInvariantCultureの場合と結果が似ているので分かりにくいですが、CurrentCultureの場合は''亜''(あ)の方が''井''(い)より小さい(前に並ぶ)、つまり"''亜''<''井''"とされるのに対し、Ordnalの場合は''井''(U+4E95)の方が''亜''(U+4E9C)よりも小さい(前に並ぶ)、つまり"''亜''>''井''"とされるため、上記のような結果となります。 (0x4E9C - 0x4E95 = 0x0007 = 7である点に注目するとわかりやすいかもしれません)
+

          
+
また、次のような例をとって違いを見てみます。
+

          
+
#tabpage(C#)
+
#code(cs){{
+
using System;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    string[] p1 = new string[] {"coop", "co-op"};
+
    string[] p2 = new string[] {"cant", "can't"};
+

          
+
    Console.WriteLine("Compare CurrentCulture ({0}, {1}) : {2}", p1[0], p1[1], String.Compare(p1[0], p1[1], StringComparison.CurrentCulture));
+
    Console.WriteLine("Compare Ordinal        ({0}, {1}) : {2}", p1[0], p1[1], String.Compare(p1[0], p1[1], StringComparison.Ordinal));
+

          
+
    Console.WriteLine("Compare CurrentCulture ({0}, {1}) : {2}", p2[0], p2[1], String.Compare(p2[0], p2[1], StringComparison.CurrentCulture));
+
    Console.WriteLine("Compare Ordinal        ({0}, {1}) : {2}", p2[0], p2[1], String.Compare(p2[0], p2[1], StringComparison.Ordinal));
+
  }
+
}
+
}}
+
#tabpage(VB)
+
#code(vb){{
+
Imports System
+

          
+
Class Sample
+
  Shared Sub Main()
+
    Dim p1 As String() = New String() {"coop", "co-op"}
+
    Dim p2 As String() = New String() {"cant", "can't"}
+

          
+
    Console.WriteLine("Compare CurrentCulture ({0}, {1}) : {2}", p1(0), p1(1), String.Compare(p1(0), p1(1), StringComparison.CurrentCulture))
+
    Console.WriteLine("Compare Ordinal        ({0}, {1}) : {2}", p1(0), p1(1), String.Compare(p1(0), p1(1), StringComparison.Ordinal))
+

          
+
    Console.WriteLine("Compare CurrentCulture ({0}, {1}) : {2}", p2(0), p2(1), String.Compare(p2(0), p2(1), StringComparison.CurrentCulture))
+
    Console.WriteLine("Compare Ordinal        ({0}, {1}) : {2}", p2(0), p2(1), String.Compare(p2(0), p2(1), StringComparison.Ordinal))
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
+

          
+
#prompt{{
+
Compare CurrentCulture (coop, co-op) : -1
+
Compare Ordinal        (coop, co-op) : 66
+
Compare CurrentCulture (cant, can't) : -1
+
Compare Ordinal        (cant, can't) : 77
+
}}
+

          
+
CurrentCultureの場合は辞書的な並びでの比較となり、"coop"は"co-op"よりも前、"cant"は"can't"よりも前、つまり"''coop''<''co-op''"、"''cant''<''can't''"という結果になります。
+

          
+
対してOrdinalの場合ですが、"coop"と"co-op"の3文字目を比較すると''o''(U+006F)と''-''(U+002D)であるため"''coop''>''co-op''"という結果になります。 同様に、"cant"と"can't"の3文字目は''t''(U+0074)と'(U+0027)であるため"''cant''>''can't''"という結果になります。 (この結果も、0x006F - 0x002D = 0x0042 = 66、0x0074-0x0027 = 0x004D = 77である点に注目するとよりわかりやすいかもしれません)
+

          
+
**&aname(StringComparer){StringComparerクラス};
+
&msdn(netfx,type,System.StringComparer){StringComparerクラス};は文字列比較の実装を提供するクラスです。 IComparer<string>、IEqualityComparer<string>を実装しているため、これらのインターフェイスを使った文字列比較を行う際は、このクラスのインスタンスを使うことが出来ます。 また、[[StringComparison>#StringComparison]]と対応する実装を提供する静的プロパティも用意されています。
+

          
+
|*StringComparerのプロパティとStringComparisonの対応
+
|~StringComparerのプロパティ|~同等なStringComparison|h
+
|StringComparer.CurrentCulture|StringComparison.CurrentCulture|
+
|StringComparer.CurrentCultureIgnoreCase|StringComparison.CurrentCultureIgnoreCase|
+
|StringComparer.InvariantCulture|StringComparison.InvariantCulture|
+
|StringComparer.InvariantCultureIgnoreCase|StringComparison.InvariantCultureIgnoreCase|
+
|StringComparer.Ordinal|StringComparison.Ordinal|
+
|StringComparer.OrdinalIgnoreCase|StringComparison.OrdinalIgnoreCase|
+

          
+
***StringComparerとソート
+
例として、StringComparerとList<string>.Sortメソッドを使って、その結果の違いを見てみます。 List<string.Sortメソッドは並べ替え時の比較を行うためのIComparer<string>を引数にとるため、StringComparerを使用することが出来ます。
+

          
+
#tabpage(C#)
+
#code(cs){{
+
using System;
+
using System.Collections.Generic;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    List<string> words = new List<string>() {"cant", "can't", "can not", "cannot"};
+

          
+
    Console.WriteLine(String.Join(", ", words.ToArray()));
+

          
+
    words.Sort(StringComparer.CurrentCulture);
+

          
+
    Console.WriteLine(String.Join(", ", words.ToArray()));
+

          
+
    words.Sort(StringComparer.Ordinal);
+

          
+
    Console.WriteLine(String.Join(", ", words.ToArray()));
+
  }
+
}
+
}}
+
#tabpage(VB)
+
#code(vb){{
+
Imports System
+
Imports System.Collections.Generic
+

          
+
Class Sample
+
  Shared Sub Main()
+
    Dim words As New List(Of String)
+

          
+
    words.AddRange(New String() {"cant", "can't", "can not", "cannot"})
+

          
+
    Console.WriteLine(String.Join(", ", words.ToArray()))
+

          
+
    words.Sort(StringComparer.CurrentCulture)
+

          
+
    Console.WriteLine(String.Join(", ", words.ToArray()))
+

          
+
    words.Sort(StringComparer.Ordinal)
+

          
+
    Console.WriteLine(String.Join(", ", words.ToArray()))
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
+

          
+
#prompt{{
+
cant, can't, can not, cannot
+
can not, cannot, cant, can't
+
can not, can't, cannot, cant
+
}}
+

          
+
Dictionary<string, T>では、コンストラクタでキーの比較を行うためのIEqualityComparer<string>を指定することが出来るため、StringComparerを指定することでキーの大文字小文字を無視するディクショナリを作成することも出来ます。
+

          
+
#tabpage(C#)
+
#code(cs){{
+
using System;
+
using System.Collections.Generic;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    Dictionary<string, string> dict1 = new Dictionary<string, string>(StringComparer.InvariantCulture);
+
    Dictionary<string, string> dict2 = new Dictionary<string, string>(StringComparer.InvariantCultureIgnoreCase);
+

          
+
    dict1["foo"] = "bar";
+
    dict1["Foo"] = "Bar";
+
    dict1["FOO"] = "BAR";
+

          
+
    dict2["foo"] = "bar";
+
    dict2["Foo"] = "Bar";
+
    dict2["FOO"] = "BAR";
+

          
+
    Console.WriteLine("dict1");
+

          
+
    foreach (KeyValuePair<string, string> p in dict1)
+
    {
+
      Console.WriteLine("{0} = {1}", p.Key, p.Value);
+
    }
+

          
+
    Console.WriteLine("dict2");
+

          
+
    foreach (KeyValuePair<string, string> p in dict2)
+
    {
+
      Console.WriteLine("{0} = {1}", p.Key, p.Value);
+
    }
+
  }
+
}
+
}}
+
#tabpage(VB)
+
#code(vb){{
+
Imports System
+
Imports System.Collections.Generic
+

          
+
Class Sample
+
  Shared Sub Main()
+
    Dim dict1 As New Dictionary(Of String, String)(StringComparer.InvariantCulture)
+
    Dim dict2 As New Dictionary(Of String, String)(StringComparer.InvariantCultureIgnoreCase)
+

          
+
    dict1("foo") = "bar"
+
    dict1("Foo") = "Bar"
+
    dict1("FOO") = "BAR"
+

          
+
    dict2("foo") = "bar"
+
    dict2("Foo") = "Bar"
+
    dict2("FOO") = "BAR"
+

          
+
    Console.WriteLine("dict1")
+

          
+
    For Each p As KeyValuePair(Of String, String) In dict1
+
      Console.WriteLine("{0} = {1}", p.Key, p.Value)
+
    Next
+

          
+
    Console.WriteLine("dict2")
+

          
+
    For Each p As KeyValuePair(Of String, String) In dict2
+
      Console.WriteLine("{0} = {1}", p.Key, p.Value)
+
    Next
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
+

          
+
#prompt{{
+
dict1
+
foo = bar
+
Foo = Bar
+
FOO = BAR
+
dict2
+
foo = BAR
+
}}
+

          
+
Array.Sortメソッドも、ソート時の比較処理をIComparerで指定することが出来ます。 次のコードは、CurrentCultureとOrdinalでアラビア数字・漢数字・囲み文字を並べ替えたときの違いを出力する例です。
+

          
+
#code(cs){{
+
using System;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    string[] numbers = new string[] {
+
      // 半角アラビア数字
+
      "1", "2", "3", "4", "5", "6", "7", "8", "9", "10",
+
      // 丸囲みアラビア数字
+
      "①", "②", "③", "④", "⑤", "⑥", "⑦", "⑧", "⑨", "⑩",
+
      // 括弧囲みアラビア数字
+
      "⑴", "⑵", "⑶", "⑷", "⑸", "⑹", "⑺", "⑻", "⑼", "⑽",
+
      // 終止符付きアラビア数字
+
      "⒈", "⒉", "⒊", "⒋", "⒌", "⒍", "⒎", "⒏", "⒐", "⒑",
+
      // 漢数字
+
      "一", "二", "三", "四", "五", "六", "七", "八", "九", "十",
+
      // 丸囲み漢数字
+
      "㊀", "㊁", "㊂", "㊃", "㊄", "㊅", "㊆", "㊇", "㊈", "㊉",
+
      // 括弧囲み漢数字
+
      "㈠", "㈡", "㈢", "㈣", "㈤", "㈥", "㈦", "㈧", "㈨", "㈩",
+
    };
+

          
+
    Console.WriteLine("StringComparer.CurrentCulture");
+

          
+
    Array.Sort(numbers, StringComparer.CurrentCulture);
+

          
+
    for (var i = 0; i < numbers.Length; i++) {
+
      Console.Write("{0} ", numbers[i]);
+

          
+
      if (i % 20 == 19)
+
        Console.WriteLine();
+
    }
+

          
+
    Console.WriteLine();
+

          
+
    Console.WriteLine("StringComparer.Ordinal");
+

          
+
    Array.Sort(numbers, StringComparer.Ordinal);
+

          
+
    for (var i = 0; i < numbers.Length; i++) {
+
      Console.Write("{0} ", numbers[i]);
+

          
+
      if (i % 20 == 19)
+
        Console.WriteLine();
+
    }
+

          
+
    Console.WriteLine();
+
  }
+
}
+
}}
+

          
+
#prompt{{
+
StringComparer.CurrentCulture
+
1 ① ⑴ ⒈ 10 2 ② ⑵ ⒉ 3 ③ ⑶ ⒊ 4 ④ ⑷ ⒋ 5 ⑤ ⑸ 
+
⒌ 6 ⑥ ⑹ ⒍ 7 ⑦ ⑺ ⒎ 8 ⑧ ⑻ ⒏ 9 ⑨ ⑼ ⒐ ⑩ ⑽ ⒑ 
+
一 ㈠ ㊀ 九 ㈨ ㊈ 五 ㈤ ㊄ 三 ㈢ ㊂ 四 ㈣ ㊃ 七 ㈦ ㊆ 十 ㈩ 
+
㊉ 二 ㈡ ㊁ 八 ㈧ ㊇ 六 ㈥ ㊅ 
+
StringComparer.Ordinal
+
1 10 2 3 4 5 6 7 8 9 ① ② ③ ④ ⑤ ⑥ ⑦ ⑧ ⑨ ⑩ 
+
⑴ ⑵ ⑶ ⑷ ⑸ ⑹ ⑺ ⑻ ⑼ ⑽ ⒈ ⒉ ⒊ ⒋ ⒌ ⒍ ⒎ ⒏ ⒐ ⒑ 
+
㈠ ㈡ ㈢ ㈣ ㈤ ㈥ ㈦ ㈧ ㈨ ㈩ ㊀ ㊁ ㊂ ㊃ ㊄ ㊅ ㊆ ㊇ ㊈ ㊉ 
+
一 七 三 九 二 五 八 六 十 四 
+
}}
+

          
+
CurrentCultureでは、アラビア数字は数字の大きさ、漢数字は漢字の読みに従って並べ替えられ、Ordinalではコードポイントに従って並べ替えられていることが分かると思います。
+

          
+
*&aname(CompareOptions){CompareOptions列挙型};
+
&msdn(netfx,type,System.Globalization.CompareOptions){CompareOptions列挙型};も、StringComparisonと同じく文字列比較の際の動作を指定するための列挙型ですが、StringComparisonよりも具体的な指定を行うことが出来ます。 StringComparisonの場合と異なり、Stringクラスでは&msdn(netfx,method,System.String.Compare){Compareメソッド};のみがCompareOptionsを指定した比較をサポートしています。
+

          
+
CompareOptionsを指定する場合は、次の値を組み合わせて指定できます。
+
|*CompareOptions
+
|~CompareOptionsの値|~文字列比較時の動作|h
+
|None|デフォルトの動作で比較する|
+
|IgnoreCase|大文字小文字の違いを無視して比較する|
+
|IgnoreKanaType|ひらがなとカタカナの違いを無視して比較する|
+
|IgnoreWidth|全角と半角の違いを無視して比較する|
+
|IgnoreNonSpace|濁点付きの文字、囲み文字や発音記号など、基本となる文字と修飾記号の組み合わせになる文字について、'''非スペーシング組み合わせ文字'''となる修飾記号を無視して比較する|
+
|IgnoreSymbols|空白文字・句読点・その他の記号を無視して比較する|
+
|StringSort|ハイフン・アポストロフィが英数字や他の記号よりも前になるように比較する|
+
|Ordinal|文字列の各文字を数値(Unicode序数、Unicode ordinal)=コードポイントで比較する&br;(StringComparison.Ordinalと同じ)|
+
|OrdinalIgnoreCase|文字列の各文字を数値(Unicode序数、Unicode ordinal)=コードポイントで比較する&br;大文字小文字の違いは無視する&br;(StringComparison.OrdinalIgnoreCaseと同じ)|
+

          
+
なお、OrdinalとOrdinalIgnoreCaseは他の値とは組み合わせることはできないため、単独で使用する必要があります。 また、CompareOptionsを指定する場合は、CompareOptionsと合わせてCultureInfoも指定する必要があります。
+

          
+
以下はString.CompareメソッドにCompareOptionsを指定する例です。
+

          
+
#tabpage(C#)
+
#code(cs){{
+
using System;
+
using System.Globalization;
+
using System.Threading;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    Console.WriteLine("CompareOptions.None       : {0}", String.Compare("abc", "ABC", Thread.CurrentThread.CurrentCulture, CompareOptions.None));
+
    Console.WriteLine("CompareOptions.IgnoreCase : {0}", String.Compare("abc", "ABC", Thread.CurrentThread.CurrentCulture, CompareOptions.IgnoreCase));
+
  }
+
}
+
}}
+
#tabpage(VB)
+
#code(vb){{
+
Imports System
+
Imports System.Globalization
+
Imports System.Threading
+

          
+
Class Sample
+
  Shared Sub Main()
+
    Console.WriteLine("CompareOptions.None       : {0}", String.Compare("abc", "ABC", Thread.CurrentThread.CurrentCulture, CompareOptions.None))
+
    Console.WriteLine("CompareOptions.IgnoreCase : {0}", String.Compare("abc", "ABC", Thread.CurrentThread.CurrentCulture, CompareOptions.IgnoreCase))
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
+

          
+
#prompt{{
+
CompareOptions.None       : -1
+
CompareOptions.IgnoreCase : 0
+
}}
+

          
+
**IgnoreCase, IgnoreKanaType, IgnoreWidth
+
IgnoreCase, IgnoreKanaType, IgnoreWidthはそれぞれ大文字小文字、ひらがなとカタカナ、全角と半角を区別しないで比較するように指定します。 これらの値や他の値と組み合わせて使用することも出来ます。
+

          
+
#tabpage(C#)
+
#code(cs){{
+
using System;
+
using System.Globalization;
+
using System.Threading;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    Console.WriteLine(Thread.CurrentThread.CurrentCulture);
+

          
+
    Compare("abc", "ABC", CompareOptions.None);
+
    Compare("abc", "ABC", CompareOptions.IgnoreCase);
+
    Compare("abc", "abc", CompareOptions.IgnoreWidth);
+
    Compare("abc", "ABC", CompareOptions.IgnoreCase);
+
    Compare("abc", "ABC", CompareOptions.IgnoreCase | CompareOptions.IgnoreWidth);
+

          
+
    Console.WriteLine();
+

          
+
    Compare("あいうえお", "アイウエオ", CompareOptions.None);
+
    Compare("あいうえお", "アイウエオ", CompareOptions.IgnoreKanaType);
+
    Compare("アイウエオ", "アイウエオ", CompareOptions.None);
+
    Compare("アイウエオ", "アイウエオ", CompareOptions.IgnoreWidth);
+
    Compare("アイウエオ", "あいうえお", CompareOptions.IgnoreKanaType);
+
    Compare("アイウエオ", "あいうえお", CompareOptions.IgnoreKanaType | CompareOptions.IgnoreWidth);
+
  }
+

          
+
  private static void Compare(string s1, string s2, CompareOptions options)
+
  {
+
    Console.WriteLine("{0} {1} : {2,2} ({3:f})", s1, s2, String.Compare(s1, s2, Thread.CurrentThread.CurrentCulture, options), options);
+
  }
+
}
+
}}
+
#tabpage(VB)
+
#code(vb){{
+
Imports System
+
Imports System.Globalization
+
Imports System.Threading
+

          
+
Class Sample
+
  Shared Sub Main()
+
    Console.WriteLine(Thread.CurrentThread.CurrentCulture)
+

          
+
    Compare("abc", "ABC", CompareOptions.None)
+
    Compare("abc", "ABC", CompareOptions.IgnoreCase)
+
    Compare("abc", "abc", CompareOptions.IgnoreWidth)
+
    Compare("abc", "ABC", CompareOptions.IgnoreCase)
+
    Compare("abc", "ABC", CompareOptions.IgnoreCase Or CompareOptions.IgnoreWidth)
+

          
+
    Console.WriteLine()
+

          
+
    Compare("あいうえお", "アイウエオ", CompareOptions.None)
+
    Compare("あいうえお", "アイウエオ", CompareOptions.IgnoreKanaType)
+
    Compare("アイウエオ", "アイウエオ", CompareOptions.None)
+
    Compare("アイウエオ", "アイウエオ", CompareOptions.IgnoreWidth)
+
    Compare("アイウエオ", "あいうえお", CompareOptions.IgnoreKanaType)
+
    Compare("アイウエオ", "あいうえお", CompareOptions.IgnoreKanaType Or CompareOptions.IgnoreWidth)
+
  End Sub
+

          
+
  Private Shared Sub Compare(ByVal s1 As String, ByVal s2 As String, ByVal options As CompareOptions)
+
    Console.WriteLine("{0} {1} : {2,2} ({3:f})", s1, s2, String.Compare(s1, s2, Thread.CurrentThread.CurrentCulture, options), options)
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
+

          
+
#prompt{{
+
ja-JP
+
abc ABC : -1 (None)
+
abc ABC :  0 (IgnoreCase)
+
abc abc :  0 (IgnoreWidth)
+
abc ABC : -1 (IgnoreCase)
+
abc ABC :  0 (IgnoreCase, IgnoreWidth)
+

          
+
あいうえお アイウエオ :  1 (None)
+
あいうえお アイウエオ :  0 (IgnoreKanaType)
+
アイウエオ アイウエオ : -1 (None)
+
アイウエオ アイウエオ :  0 (IgnoreWidth)
+
アイウエオ あいうえお : -1 (IgnoreKanaType)
+
アイウエオ あいうえお :  0 (IgnoreKanaType, IgnoreWidth)
+
}}
+

          
+
**IgnoreNonSpace
+
IgnoreNonSpaceは、濁点付きの文字、囲み文字や発音記号など、基本となる文字と修飾記号の組み合わせになる文字について、その組み合わせを無視して比較するように指定します。 これらの値や他の値と組み合わせて使用することも出来ます。 &msdn(netfx,type,System.Globalization.CompareOptions){CompareOptions.IgnoreNonSpace};の解説では、
+
>文字列比較で、発音区別符など、非スペーシング組み合わせ文字を無視するように指定します。Unicode 標準は、新しい文字を生成するために基本文字と組み合わせられる文字を組み合わせ文字として定義しています。非スペーシング組み合わせ文字は、表示されるときに文字間隔用の領域は確保しません。
+
とされています。 '''非スペーシング組み合わせ文字'''とは、Unicodeのカテゴリ'Mark, Nonspacing' [Mn]のことで、これに該当する文字は比較の際に無視されることになります。
+

          
+
まずは、具体的な例と比較結果を見てみます。
+

          
+
#tabpage(C#)
+
#code(cs){{
+
using System;
+
using System.Globalization;
+
using System.Threading;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    Console.WriteLine(Thread.CurrentThread.CurrentCulture);
+

          
+
    Compare("cafe", "café", CompareOptions.None);
+
    Compare("cafe", "café", CompareOptions.IgnoreNonSpace);
+

          
+
    Compare("cat", "cæt", CompareOptions.None);
+
    Compare("cat", "cæt", CompareOptions.IgnoreNonSpace);
+
    Compare("caet", "cæt", CompareOptions.None);
+
    Compare("caet", "cæt", CompareOptions.IgnoreNonSpace);
+
    Compare("caet", "cæt", CompareOptions.Ordinal);
+

          
+
    Console.WriteLine();
+

          
+
    Compare("えと", "えど", CompareOptions.None);
+
    Compare("えと", "えど", CompareOptions.IgnoreNonSpace);
+
    Compare("ハン", "パン", CompareOptions.None);
+
    Compare("ハン", "パン", CompareOptions.IgnoreNonSpace);
+
    Compare("ウ", "ヴ", CompareOptions.None);
+
    Compare("ウ", "ヴ", CompareOptions.IgnoreNonSpace);
+

          
+
    Console.WriteLine();
+

          
+
    Compare("バ゙ン", "パン", CompareOptions.None);
+
    Compare("◎゛", "●", CompareOptions.None);
+

          
+
    Console.WriteLine();
+

          
+
    Compare("C", "©", CompareOptions.None);
+
    Compare("C", "©", CompareOptions.IgnoreNonSpace);
+
    Compare("C", "Ⓒ", CompareOptions.None);
+
    Compare("C", "Ⓒ", CompareOptions.IgnoreNonSpace);
+

          
+
    Console.WriteLine();
+

          
+
    Compare("1", "①", CompareOptions.None);
+
    Compare("1", "①", CompareOptions.IgnoreNonSpace);
+
    Compare("1", "①", CompareOptions.IgnoreNonSpace);
+
    Compare("1", "①", CompareOptions.IgnoreNonSpace | CompareOptions.IgnoreWidth);
+
  }
+

          
+
  private static void Compare(string s1, string s2, CompareOptions options)
+
  {
+
    Console.WriteLine("{0} {1} : {2,2} ({3:f})", s1, s2, String.Compare(s1, s2, Thread.CurrentThread.CurrentCulture, options), options);
+
  }
+
}
+
}}
+
#tabpage(VB)
+
#code(vb){{
+
Imports System
+
Imports System.Globalization
+
Imports System.Threading
+

          
+
Class Sample
+
  Shared Sub Main()
+
    Console.WriteLine(Thread.CurrentThread.CurrentCulture)
+

          
+
    Compare("cafe", "café", CompareOptions.None)
+
    Compare("cafe", "café", CompareOptions.IgnoreNonSpace)
+

          
+
    Compare("cat", "cæt", CompareOptions.None)
+
    Compare("cat", "cæt", CompareOptions.IgnoreNonSpace)
+
    Compare("caet", "cæt", CompareOptions.None)
+
    Compare("caet", "cæt", CompareOptions.IgnoreNonSpace)
+
    Compare("caet", "cæt", CompareOptions.Ordinal)
+

          
+
    Console.WriteLine()
+

          
+
    Compare("えと", "えど", CompareOptions.None)
+
    Compare("えと", "えど", CompareOptions.IgnoreNonSpace)
+
    Compare("ハン", "パン", CompareOptions.None)
+
    Compare("ハン", "パン", CompareOptions.IgnoreNonSpace)
+
    Compare("ウ", "ヴ", CompareOptions.None)
+
    Compare("ウ", "ヴ", CompareOptions.IgnoreNonSpace)
+

          
+
    Console.WriteLine()
+

          
+
    Compare("バ゙ン", "パン", CompareOptions.None)
+
    Compare("◎゛", "●", CompareOptions.None)
+

          
+
    Console.WriteLine()
+

          
+
    Compare("C", "©", CompareOptions.None)
+
    Compare("C", "©", CompareOptions.IgnoreNonSpace)
+
    Compare("C", "Ⓒ", CompareOptions.None)
+
    Compare("C", "Ⓒ", CompareOptions.IgnoreNonSpace)
+

          
+
    Console.WriteLine()
+

          
+
    Compare("1", "①", CompareOptions.None)
+
    Compare("1", "①", CompareOptions.IgnoreNonSpace)
+
    Compare("1", "①", CompareOptions.IgnoreNonSpace)
+
    Compare("1", "①", CompareOptions.IgnoreNonSpace Or CompareOptions.IgnoreWidth)
+
  End Sub
+

          
+
  Private Shared Sub Compare(ByVal s1 As String, ByVal s2 As String, ByVal options As CompareOptions)
+
    Console.WriteLine("{0} {1} : {2,2} ({3:f})", s1, s2, String.Compare(s1, s2, Thread.CurrentThread.CurrentCulture, options), options)
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
+

          
+
#prompt{{
+
ja-JP
+
cafe café : -1 (None)
+
cafe café :  0 (IgnoreNonSpace)
+
cat cæt :  1 (None)
+
cat cæt :  1 (IgnoreNonSpace)
+
caet cæt :  0 (None)
+
caet cæt : -133 (Ordinal)
+

          
+
えと えど : -1 (None)
+
えと えど :  0 (IgnoreNonSpace)
+
ハン パン : -1 (None)
+
ハン パン :  0 (IgnoreNonSpace)
+
ウ ヴ : -1 (None)
+
ウ ヴ :  0 (IgnoreNonSpace)
+

          
+
バ゙ン パン :  0 (None)
+
◎゛ ● :  0 (None)
+

          
+
C © :  1 (None)
+
C © :  1 (IgnoreNonSpace)
+
C Ⓒ : -1 (None)
+
C Ⓒ :  0 (IgnoreNonSpace)
+

          
+
1 ① : -1 (None)
+
1 ① :  0 (IgnoreNonSpace)
+
1 ① :  1 (IgnoreNonSpace)
+
1 ① :  0 (IgnoreNonSpace, IgnoreWidth)
+
}}
+

          
+
個々の実行結果について、詳しく説明します。
+

          
+
:"cafe"と"café"|''&#x00e9;''(U+00E9 LATIN SMALL LETTER E WITH ACUTE)は''&#x0065;''(U+0065 LATIN SMALL LETTER E)と''&#x0301;''(U+0301 COMBINING ACUTE ACCENT)の組み合わせと等価とされています。
+
IgnoreNonSpaceの場合、カテゴリが'Mark, Nonspacing'である''&#x0301;''(U+0301 COMBINING ACUTE ACCENT)が無視され、''&#x0065;''(U+0065 LATIN SMALL LETTER E)として比較されるため、"cafe"と"café"は同じであると判断されます。
+
:"cat"と"cæt"|''&#x00E6;''(U+00E6 LATIN SMALL LETTER AE)は組み合わせた文字としては扱われないため、IgnoreNonSpaceの場合でも"cat"と"cæt"は異なると判断されます。
+
:"caet"と"cæt"|インバリアントカルチャおよびja-JPでは"ae"と"&#x00E6;"は同等であると判断されるため、NoneでもIgnoreNonSpaceでも"caet"と"cæt"は同じであると判断されます。
+
Ordinalの場合、''&#x0061;''(U+0061 LATIN SMALL LETTER A)と''&#x00E6;''(U+00E6 LATIN SMALL LETTER AE)はコードポイントが異なるため、"caet"と"cæt"は異なると判断されます。
+
:"えと"と"えど"|''&#x3069;''(U+3069 HIRAGANA LETTER DO)は''&#x3068;''(U+3068 HIRAGANA LETTER TO)と''&#x3099;''(U+3099 COMBINING KATAKANA-HIRAGANA VOICED SOUND MARK)の組み合わせと等価とされています。
+
IgnoreNonSpaceの場合、カテゴリが'Mark, Nonspacing'である''&#x3099;''(U+3099 COMBINING KATAKANA-HIRAGANA VOICED SOUND MARK)が無視され、''&#x3068;''(U+3068 HIRAGANA LETTER TO)として比較されるため、"えと"と"えど"は同じであると判断されます。
+
:"ハン"と"パン"&br;"ウ"と"ヴ"|''&#x30D1;''(U+30D1 KATAKANA LETTER PA)は''&#x30CF;''(U+30CF KATAKANA LETTER HA)と''&#x309A;''(U+309A COMBINING KATAKANA-HIRAGANA SEMI-VOICED SOUND MARK)の組み合わせ、''&#x30F4;''(U+30F4 KATAKANA LETTER VU)は''&#x30A6;''(U+30A6 KATAKANA LETTER U)と''&#x3099;''(U+3099 COMBINING KATAKANA-HIRAGANA VOICED SOUND MARK)の組み合わせと等価とされています。
+
従って"えと"と"えど"の場合と同様、IgnoreNonSpaceの場合は濁点・半濁点が無視され、"ハン"と"パン"、"ウ"と"ヴ"はそれぞれ同じであると判断されます。
+
:"バ゙ン"と"パン"&br;"◎゛ "と"●"|''&#x30CF;''(U+30CF KATAKANA LETTER HA)に濁点が二つつけられたものと''&#x30D1;''(U+30D1 KATAKANA LETTER PA)は等しくなります。 これは、濁点が基本となる文字に対して'''重み1'''を与え、半濁点が'''重み2'''を与えるためで、濁点二つと半濁点一つではどちらも同じ'''重み'''が与えられます。 その結果、"バ゙ン"と"パン"は同じであると判断されます。
+
''&#x25CE;''(U+25CE BULLSEYE)に濁点がつけられたものと''&#x25CF;''(U+25CF BLACK CIRCLE)が等しくなるのもこれと同じで、濁点によって'''重み'''が与えらることにより、"◎゛ "と"●"は同じであると判断されます。
+
参考: [[「MS ACCESS 95/97 の美しいソート順」の謎に答える - ものがたり:http://d.hatena.ne.jp/atsushieno/20050704/p2]]
+
:"C"と"©"&br;"C"と"Ⓒ"|''&#x00A9;''(U+00A9 COPYRIGHT SIGN)は組み合わせた文字としては扱われないため、IgnoreNonSpaceの場合でも"C"と"©"は異なると判断されます。
+
一方''&#x24B8;''(U+24B8 CIRCLED LATIN CAPITAL LETTER C)は''&#x0043;''(U+0043 LATIN CAPITAL LETTER C)とほぼ等価とされているため、IgnoreNonSpaceの場合"C"と"Ⓒ"は同じであると判断されます。
+
:"1"と"①"&br;"1"と"①"|''&#x2460;''(U+2460 CIRCLED DIGIT ONE)は''&#x0031;''(U+0031 DIGIT ONE)とほぼ等価とされているため、IgnoreNonSpaceの場合"1"と"①"は同じであると判断されます。
+
また、''&#xFF11;''(U+FF11 FULLWIDTH DIGIT ONE)は''&#x0031;''(U+0031 DIGIT ONE)と全角半角の関係にあるため、IgnoreNonSpace+IgnoreWidthの場合"1"と"①"は同じであると判断されます。
+

          
+
**IgnoreSymbol
+
(このドキュメントは未整理です)
+

          
+
IgnoreSymbolは、空白文字、句読点等の記号を無視して比較するように指定します。 これらの値や他の値と組み合わせて使用することも出来ます。 &msdn(netfx,type,System.Globalization.CompareOptions){CompareOptions.IgnoreSymbol};の解説では、
+
>文字列比較において、空白文字、句読点、通貨記号、パーセント記号、算術記号、アンパサンドなどの記号を無視することを示します。 
+
とされているものの、具体的にどの記号が無視される対象なのかは明記されていないようです。 また、.NET FrameworkとMonoでも実行結果は異なるようです。
+

          
+
#tabpage(C#)
+
#code(cs){{
+
using System;
+
using System.Globalization;
+
using System.Threading;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    Console.WriteLine(Thread.CurrentThread.CurrentCulture);
+

          
+
    Compare("ABC", "\\A,B!C*", CompareOptions.None);
+
    Compare("ABC", "\\A,B!C*", CompareOptions.IgnoreSymbols);
+
    Compare("ABC", "A[ B ]C", CompareOptions.None);
+
    Compare("ABC", "A[ B ]C", CompareOptions.IgnoreSymbols);
+

          
+
    Console.WriteLine();
+

          
+
    Compare("あいうえお", "あ い う/え・お", CompareOptions.None);
+
    Compare("あいうえお", "あ い う/え・お", CompareOptions.IgnoreSymbols);
+
    Compare("あいうえお", "(あ){い}(う)「え」【お】", CompareOptions.None);
+
    Compare("あいうえお", "(あ){い}(う)「え」【お】", CompareOptions.IgnoreSymbols);
+
    Compare("あいうえお", "¥あ~い!う☆え@お。", CompareOptions.None);
+
    Compare("あいうえお", "¥あ~い!う☆え@お。", CompareOptions.IgnoreSymbols);
+
  }
+

          
+
  private static void Compare(string s1, string s2, CompareOptions options)
+
  {
+
    Console.WriteLine("{0} {1} : {2,2} ({3:f})", s1, s2, String.Compare(s1, s2, Thread.CurrentThread.CurrentCulture, options), options);
+
  }
+
}
+
}}
+
#tabpage(VB)
+
#code(vb){{
+
Imports System
+
Imports System.Globalization
+
Imports System.Threading
+

          
+
Class Sample
+
  Shared Sub Main()
+
    Console.WriteLine(Thread.CurrentThread.CurrentCulture)
+

          
+
    Compare("ABC", "\A,B!C*", CompareOptions.None)
+
    Compare("ABC", "\A,B!C*", CompareOptions.IgnoreSymbols)
+
    Compare("ABC", "A[ B ]C", CompareOptions.None)
+
    Compare("ABC", "A[ B ]C", CompareOptions.IgnoreSymbols)
+

          
+
    Console.WriteLine()
+

          
+
    Compare("あいうえお", "あ い う/え・お", CompareOptions.None)
+
    Compare("あいうえお", "あ い う/え・お", CompareOptions.IgnoreSymbols)
+
    Compare("あいうえお", "(あ){い}(う)「え」【お】", CompareOptions.None)
+
    Compare("あいうえお", "(あ){い}(う)「え」【お】", CompareOptions.IgnoreSymbols)
+
    Compare("あいうえお", "¥あ~い!う☆え@お。", CompareOptions.None)
+
    Compare("あいうえお", "¥あ~い!う☆え@お。", CompareOptions.IgnoreSymbols)
+
  End Sub
+

          
+
  Private Shared Sub Compare(ByVal s1 As String, ByVal s2 As String, ByVal options As CompareOptions)
+
    Console.WriteLine("{0} {1} : {2,2} ({3:f})", s1, s2, String.Compare(s1, s2, Thread.CurrentThread.CurrentCulture, options), options)
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
+

          
+
#tabpage(.NET Framework 3.5)
+
#prompt{{
+
ja-JP
+
ABC \A,B!C* :  1 (None)
+
ABC \A,B!C* :  0 (IgnoreSymbols)
+
ABC A[ B ]C :  1 (None)
+
ABC A[ B ]C :  0 (IgnoreSymbols)
+

          
+
あいうえお あ い う/え・お :  1 (None)
+
あいうえお あ い う/え・お :  1 (IgnoreSymbols)
+
あいうえお (あ){い}(う)「え」【お】 :  1 (None)
+
あいうえお (あ){い}(う)「え」【お】 :  1 (IgnoreSymbols)
+
あいうえお ¥あ〜い!う☆え@お。 :  1 (None)
+
あいうえお ¥あ〜い!う☆え@お。 :  1 (IgnoreSymbols)
+
}}
+
#tabpage(Mono 2.8)
+
#prompt{{
+
ja-JP
+
ABC \A,B!C* :  1 (None)
+
ABC \A,B!C* :  0 (IgnoreSymbols)
+
ABC A[ B ]C :  1 (None)
+
ABC A[ B ]C :  0 (IgnoreSymbols)
+

          
+
あいうえお あ い う/え・お :  1 (None)
+
あいうえお あ い う/え・お :  0 (IgnoreSymbols)
+
あいうえお (あ){い}(う)「え」【お】 :  1 (None)
+
あいうえお (あ){い}(う)「え」【お】 :  0 (IgnoreSymbols)
+
あいうえお ¥あ~い!う☆え@お。 :  1 (None)
+
あいうえお ¥あ~い!う☆え@お。 :  0 (IgnoreSymbols)
+
}}
+
#tabpage-end
+

          
+
**StringSort
+
(このドキュメントは未整理です)
+

          
+
StringSortは、ハイフン・アポストロフィが英数字や他の記号よりも前になるように比較するように指定します。 これらの値や他の値と組み合わせて使用することも出来ます。 &msdn(netfx,type,System.Globalization.CompareOptions){CompareOptions.StringSort};の解説では、
+
>	文字列の比較時に、文字列での並べ替えアルゴリズムを使用することを示します。文字列での並べ替えでは、ハイフン、アポストロフィ、およびその他の英数字以外の記号が英数字よりも前に来ます。
+
とされているものの、具体的にハイフン・アポストロフィ以外のどの記号が無視される対象なのかは明記されていないようです。 また、.NET FrameworkとMonoでも実行結果は異なるようです。
+

          
+
#tabpage(C#)
+
#code(cs){{
+
using System;
+
using System.Globalization;
+
using System.Threading;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    Console.WriteLine(Thread.CurrentThread.CurrentCulture);
+

          
+
    Compare("cant", "can't", CompareOptions.None);
+
    Compare("cant", "can't", CompareOptions.StringSort);
+
    Compare("cant", "can't", CompareOptions.Ordinal);
+

          
+
    Console.WriteLine();
+

          
+
    Compare("coop", "co-op", CompareOptions.None);
+
    Compare("coop", "co-op", CompareOptions.StringSort);
+
    Compare("coop", "co-op", CompareOptions.Ordinal);
+

          
+
    Console.WriteLine();
+

          
+
    Compare("あい", "あ-い", CompareOptions.None);
+
    Compare("あい", "あ-い", CompareOptions.StringSort);
+
    Compare("あい", "あ-い", CompareOptions.Ordinal);
+

          
+
    Console.WriteLine();
+

          
+
    Compare("coop", "co#op", CompareOptions.None);
+
    Compare("coop", "co#op", CompareOptions.StringSort);
+
    Compare("coop", "co@op", CompareOptions.None);
+
    Compare("coop", "co@op", CompareOptions.StringSort);
+
    Compare("co-op", "co#op", CompareOptions.None);
+
    Compare("co-op", "co#op", CompareOptions.StringSort);
+
    Compare("co-op", "co@op", CompareOptions.None);
+
    Compare("co-op", "co@op", CompareOptions.StringSort);
+
  }
+

          
+
  private static void Compare(string s1, string s2, CompareOptions options)
+
  {
+
    Console.WriteLine("{0} {1} : {2,2} ({3:f})", s1, s2, String.Compare(s1, s2, Thread.CurrentThread.CurrentCulture, options), options);
+
  }
+
}
+
}}
+
#tabpage(VB)
+
#code(vb){{
+
Imports System
+
Imports System.Globalization
+
Imports System.Threading
+

          
+
Class Sample
+
  Shared Sub Main()
+
    Console.WriteLine(Thread.CurrentThread.CurrentCulture)
+

          
+
    Compare("cant", "can't", CompareOptions.None)
+
    Compare("cant", "can't", CompareOptions.StringSort)
+
    Compare("cant", "can't", CompareOptions.Ordinal)
+

          
+
    Console.WriteLine()
+

          
+
    Compare("coop", "co-op", CompareOptions.None)
+
    Compare("coop", "co-op", CompareOptions.StringSort)
+
    Compare("coop", "co-op", CompareOptions.Ordinal)
+

          
+
    Console.WriteLine()
+

          
+
    Compare("あい", "あ-い", CompareOptions.None)
+
    Compare("あい", "あ-い", CompareOptions.StringSort)
+
    Compare("あい", "あ-い", CompareOptions.Ordinal)
+

          
+
    Console.WriteLine()
+

          
+
    Compare("coop", "co#op", CompareOptions.None)
+
    Compare("coop", "co#op", CompareOptions.StringSort)
+
    Compare("coop", "co@op", CompareOptions.None)
+
    Compare("coop", "co@op", CompareOptions.StringSort)
+
    Compare("co-op", "co#op", CompareOptions.None)
+
    Compare("co-op", "co#op", CompareOptions.StringSort)
+
    Compare("co-op", "co@op", CompareOptions.None)
+
    Compare("co-op", "co@op", CompareOptions.StringSort)
+
  End Sub
+

          
+
  Private Shared Sub Compare(ByVal s1 As String, ByVal s2 As String, ByVal options As CompareOptions)
+
    Console.WriteLine("{0} {1} : {2,2} ({3:f})", s1, s2, String.Compare(s1, s2, Thread.CurrentThread.CurrentCulture, options), options)
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
 

        

        
~
#tabpage(.NET Framework 3.5)
次のコードが示すように、String型は.NET FrameworkにおけるSystem.String型のエイリアス名で、両者は全く同じものです。 また、文字列型はクラスであるため参照型となります。 さらに、文字列型がクラス型となったため様々なメソッドを持つようになりました。
+
#prompt{{
+
ja-JP
+
cant can't : -1 (None)
+
cant can't :  1 (StringSort)
+
cant can't : 77 (Ordinal)
+

          
+
coop co-op : -1 (None)
+
coop co-op :  1 (StringSort)
+
coop co-op : 66 (Ordinal)
+

          
+
あい あ-い :  1 (None)
+
あい あ-い :  1 (StringSort)
+
あい あ-い : -52937 (Ordinal)
+

          
+
coop co#op :  1 (None)
+
coop co#op :  1 (StringSort)
+
coop co@op :  1 (None)
+
coop co@op :  1 (StringSort)
+
co-op co#op :  1 (None)
+
co-op co#op : -1 (StringSort)
+
co-op co@op :  1 (None)
+
co-op co@op : -1 (StringSort)
+
}}
+
#tabpage(Mono 2.8)
+
#prompt{{
+
ja-JP
+
cant can't : -1 (None)
+
cant can't :  0 (StringSort)
+
cant can't : 77 (Ordinal)
+

          
+
coop co-op : -1 (None)
+
coop co-op :  0 (StringSort)
+
coop co-op : 66 (Ordinal)
+

          
+
あい あ-い : -1 (None)
+
あい あ-い :  0 (StringSort)
+
あい あ-い : -52937 (Ordinal)
+

          
+
coop co#op :  1 (None)
+
coop co#op :  1 (StringSort)
+
coop co@op :  1 (None)
+
coop co@op :  1 (StringSort)
+
co-op co#op :  1 (None)
+
co-op co#op :  1 (StringSort)
+
co-op co@op :  1 (None)
+
co-op co@op :  1 (StringSort)
+
}}
+
#tabpage-end
+

          
+
**CompareOptionsとStringComparison
+
StringComparisonを指定した場合と同じ比較処理をCompareOptionsでも行うことが出来ます。 以下の表は、StringComparisonの値と、対応するCompareOptionsとCultureInfoの値の組み合わせです。
+

          
+
|*StringComparisonと等価なCompareOptionsとCultureInfoの組み合わせ
+
|~StringComparisonの値|>|~対応するCompareOptionsとCultureInfoの組み合わせ|h
+
|~|~CompareOptions|~CultureInfo|
+
|StringComparison.Ordinal|CompareOptions.Ordinal|(任意のCultureInfo)|
+
|StringComparison.OrdinalIgnoreCase|CompareOptions.OrdinalIgnoreCase|(任意のCultureInfo)|
+
|StringComparison.CurrentCulture|CompareOptions.None|CultureInfo.CurrentCulture&br;(またはThread.CurrentThread.CurrentCulture)|
+
|StringComparison.CurrentCultureIgnoreCase|CompareOptions.IgnoreCase|CultureInfo.CurrentCulture&br;(またはThread.CurrentThread.CurrentCulture)|
+
|StringComparison.InvariantCulture|CompareOptions.None|CultureInfo.InvariantCulture|
+
|StringComparison.InvariantCultureIgnoreCase|CompareOptions.IgnoreCase|CultureInfo.InvariantCulture|
+

          
+
次の例は、同じ比較処理をStringComparisonで指定した場合とCompareOptionsで指定した場合の例です。 記述は異なりますが、結果は同じです。
+

          
+
#tabpage(C#)
+
#code(cs){{
+
using System;
+
using System.Globalization;
+
using System.Threading;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    string[] p1 = new string[] {"coop", "co-op"};
+
    string[] p2 = new string[] {"亜", "井"};
+
    CultureInfo c = Thread.CurrentThread.CurrentCulture;
+

          
+
    Console.WriteLine(c);
+

          
+
    Console.WriteLine("{0} {1}", p1[0], p1[1]);
+
    Console.WriteLine("Compare StringComparison.Ordinal          : {0}", String.Compare(p1[0], p1[1], StringComparison.Ordinal));
+
    Console.WriteLine("Compare StringComparison.CurrentCulture   : {0}", String.Compare(p1[0], p1[1], StringComparison.CurrentCulture));
+
    Console.WriteLine("Compare StringComparison.InvariantCulture : {0}", String.Compare(p1[0], p1[1], StringComparison.InvariantCulture));
+
    Console.WriteLine("Compare CompareOptions.Ordinal            : {0}", String.Compare(p1[0], p1[1], c, CompareOptions.Ordinal));
+
    Console.WriteLine("Compare CompareOptions.None               : {0}", String.Compare(p1[0], p1[1], c, CompareOptions.None));
+
    Console.WriteLine("Compare CompareOptions.None (Invariant)   : {0}", String.Compare(p1[0], p1[1], CultureInfo.InvariantCulture, CompareOptions.None));
+

          
+
    Console.WriteLine("{0} {1}", p2[0], p2[1]);
+
    Console.WriteLine("Compare StringComparison.Ordinal          : {0}", String.Compare(p2[0], p2[1], StringComparison.Ordinal));
+
    Console.WriteLine("Compare StringComparison.CurrentCulture   : {0}", String.Compare(p2[0], p2[1], StringComparison.CurrentCulture));
+
    Console.WriteLine("Compare StringComparison.InvariantCulture : {0}", String.Compare(p2[0], p2[1], StringComparison.InvariantCulture));
+
    Console.WriteLine("Compare CompareOptions.Ordinal            : {0}", String.Compare(p2[0], p2[1], c, CompareOptions.Ordinal));
+
    Console.WriteLine("Compare CompareOptions.None               : {0}", String.Compare(p2[0], p2[1], c, CompareOptions.None));
+
    Console.WriteLine("Compare CompareOptions.None (Invariant)   : {0}", String.Compare(p2[0], p2[1], CultureInfo.InvariantCulture, CompareOptions.None));
+
  }
+
}
+
}}
+
#tabpage(VB)
+
#code(vb){{
+
Imports System
+
Imports System.Globalization
+
Imports System.Threading
+

          
+
Class Sample
+
  Shared Sub Main()
+
    Dim p1 As String() = New String() {"coop", "co-op"}
+
    Dim p2 As String() = New String() {"亜", "井"}
+
    Dim c As CultureInfo = Thread.CurrentThread.CurrentCulture
+

          
+
    Console.WriteLine(c)
+

          
+
    Console.WriteLine("{0} {1}", p1(0), p1(1))
+
    Console.WriteLine("Compare StringComparison.Ordinal          : {0}", String.Compare(p1(0), p1(1), StringComparison.Ordinal))
+
    Console.WriteLine("Compare StringComparison.CurrentCulture   : {0}", String.Compare(p1(0), p1(1), StringComparison.CurrentCulture))
+
    Console.WriteLine("Compare StringComparison.InvariantCulture : {0}", String.Compare(p1(0), p1(1), StringComparison.InvariantCulture))
+
    Console.WriteLine("Compare CompareOptions.Ordinal            : {0}", String.Compare(p1(0), p1(1), c, CompareOptions.Ordinal))
+
    Console.WriteLine("Compare CompareOptions.None               : {0}", String.Compare(p1(0), p1(1), c, CompareOptions.None))
+
    Console.WriteLine("Compare CompareOptions.None (Invariant)   : {0}", String.Compare(p1(0), p1(1), CultureInfo.InvariantCulture, CompareOptions.None))
+

          
+
    Console.WriteLine("{0} {1}", p2(0), p2(1))
+
    Console.WriteLine("Compare StringComparison.Ordinal          : {0}", String.Compare(p2(0), p2(1), StringComparison.Ordinal))
+
    Console.WriteLine("Compare StringComparison.CurrentCulture   : {0}", String.Compare(p2(0), p2(1), StringComparison.CurrentCulture))
+
    Console.WriteLine("Compare StringComparison.InvariantCulture : {0}", String.Compare(p2(0), p2(1), StringComparison.InvariantCulture))
+
    Console.WriteLine("Compare CompareOptions.Ordinal            : {0}", String.Compare(p2(0), p2(1), c, CompareOptions.Ordinal))
+
    Console.WriteLine("Compare CompareOptions.None               : {0}", String.Compare(p2(0), p2(1), c, CompareOptions.None))
+
    Console.WriteLine("Compare CompareOptions.None (Invariant)   : {0}", String.Compare(p2(0), p2(1), CultureInfo.InvariantCulture, CompareOptions.None))
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
+

          
+
#prompt{{
+
ja-JP
+
coop co-op
+
Compare StringComparison.Ordinal          : 66
+
Compare StringComparison.CurrentCulture   : -1
+
Compare StringComparison.InvariantCulture : -1
+
Compare CompareOptions.Ordinal            : 66
+
Compare CompareOptions.None               : -1
+
Compare CompareOptions.None (Invariant)   : -1
+
亜 井
+
Compare StringComparison.Ordinal          : 7
+
Compare StringComparison.CurrentCulture   : -1
+
Compare StringComparison.InvariantCulture : 1
+
Compare CompareOptions.Ordinal            : 7
+
Compare CompareOptions.None               : -1
+
Compare CompareOptions.None (Invariant)   : 1
+
}}
+

          
+
**CompareOptionsと部分文字列の検索・一致
+
String.Compareメソッドとは異なり、String.IndexOfなど部分文字列の検索と一致を検証するメソッドではStringComparisonを引数にとるオーバーロードは用意されていますが、CompareOptionsをとるオーバーロードは用意されていません。 CompareOptionsを使ってこれらの処理を行うには、&msdn(netfx,method,System.Globalization.CompareInfo){CompareInfoクラス};のメソッドを使う必要があります。
+

          
+
|*部分文字列の検索・一致を行うメソッド
+
|~Stringクラスのメソッド|~代用できるCompareInfoクラスのメソッド|h
+
|&msdn(netfx,method,System.String.IndexOf){String.IndexOfメソッド};|&msdn(netfx,method,System.Globalization.CompareInfo.IndexOf){CompareInfo.IndexOfメソッド};|
+
|&msdn(netfx,method,System.String.LastIndexOf){String.LastIndexOfメソッド};|&msdn(netfx,method,System.Globalization.CompareInfo.LastIndexOf){CompareInfo.LastIndexOfメソッド};|
+
|&msdn(netfx,method,System.String.StartsWith){String.StartsWithメソッド};|&msdn(netfx,method,System.Globalization.CompareInfo.IsPrefix){CompareInfo.IsPrefixメソッド};|
+
|&msdn(netfx,method,System.String.EndsWith){String.EndsWithメソッド};|&msdn(netfx,method,System.Globalization.CompareInfo.IsSuffix){CompareInfo.IsSuffixメソッド};|
+
|&msdn(netfx,method,System.String.Equals){String.Equalsメソッド};|(なし)|
+

          
+
次の例は、CompareInfoクラスの各メソッドを使った部分文字列の検索と一致の例です。
+

          
+
#tabpage(C#)
+
#code(cs){{
+
using System;
+
using System.Globalization;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    string s = "かごめかごめ かごのなかのとりは いついつでやる";
+
    CompareInfo ci = CultureInfo.InvariantCulture.CompareInfo;
+

          
+
    Console.WriteLine(s);
+

          
+
    Console.WriteLine();
+
    Console.WriteLine("IndexOf(とり、トリ)");
+
    Console.WriteLine(s.IndexOf("とり"));
+
    Console.WriteLine(s.IndexOf("トリ"));
+
    Console.WriteLine(ci.IndexOf(s, "とり"));
+
    Console.WriteLine(ci.IndexOf(s, "とり", CompareOptions.None));
+
    Console.WriteLine(ci.IndexOf(s, "トリ"));
+
    Console.WriteLine(ci.IndexOf(s, "トリ", CompareOptions.IgnoreKanaType));
+

          
+
    Console.WriteLine();
+
    Console.WriteLine("LastIndexOf(かご、カゴ)");
+
    Console.WriteLine(s.LastIndexOf("かご"));
+
    Console.WriteLine(s.LastIndexOf("カゴ"));
+
    Console.WriteLine(ci.LastIndexOf(s, "かご"));
+
    Console.WriteLine(ci.LastIndexOf(s, "カゴ"));
+
    Console.WriteLine(ci.LastIndexOf(s, "カゴ", CompareOptions.IgnoreKanaType | CompareOptions.IgnoreWidth));
+

          
+
    Console.WriteLine();
+
    Console.WriteLine("IsPrefix(かごめ、かこめ)");
+
    Console.WriteLine(s.StartsWith("かごめ"));
+
    Console.WriteLine(s.StartsWith("かこめ"));
+
    Console.WriteLine(ci.IsPrefix(s, "かごめ"));
+
    Console.WriteLine(ci.IsPrefix(s, "かこめ"));
+
    Console.WriteLine(ci.IsPrefix(s, "かこめ", CompareOptions.IgnoreNonSpace));
+

          
+
    Console.WriteLine();
+
    Console.WriteLine("IsSuffix(でやる、デヤル)");
+
    Console.WriteLine(s.EndsWith("でやる"));
+
    Console.WriteLine(s.EndsWith("デヤル"));
+
    Console.WriteLine(ci.IsSuffix(s, "でやる"));
+
    Console.WriteLine(ci.IsSuffix(s, "デヤル"));
+
    Console.WriteLine(ci.IsSuffix(s, "デヤル", CompareOptions.IgnoreKanaType));
+
  }
+
}
+
}}
+
#tabpage(VB)
+
#code(vb){{
+
Imports System
+
Imports System.Globalization
+

          
+
Class Sample
+
  Shared Sub Main()
+
    Dim s As String = "かごめかごめ かごのなかのとりは いついつでやる"
+
    Dim ci As CompareInfo = CultureInfo.InvariantCulture.CompareInfo
+

          
+
    Console.WriteLine(s)
+

          
+
    Console.WriteLine()
+
    Console.WriteLine("IndexOf(とり、トリ)")
+
    Console.WriteLine(s.IndexOf("とり"))
+
    Console.WriteLine(s.IndexOf("トリ"))
+
    Console.WriteLine(ci.IndexOf(s, "とり"))
+
    Console.WriteLine(ci.IndexOf(s, "とり", CompareOptions.None))
+
    Console.WriteLine(ci.IndexOf(s, "トリ"))
+
    Console.WriteLine(ci.IndexOf(s, "トリ", CompareOptions.IgnoreKanaType))
+

          
+
    Console.WriteLine()
+
    Console.WriteLine("LastIndexOf(かご、カゴ)")
+
    Console.WriteLine(s.LastIndexOf("かご"))
+
    Console.WriteLine(s.LastIndexOf("カゴ"))
+
    Console.WriteLine(ci.LastIndexOf(s, "かご"))
+
    Console.WriteLine(ci.LastIndexOf(s, "カゴ"))
+
    Console.WriteLine(ci.LastIndexOf(s, "カゴ", CompareOptions.IgnoreKanaType Or CompareOptions.IgnoreWidth))
+

          
+
    Console.WriteLine()
+
    Console.WriteLine("IsPrefix(かごめ、かこめ)")
+
    Console.WriteLine(s.StartsWith("かごめ"))
+
    Console.WriteLine(s.StartsWith("かこめ"))
+
    Console.WriteLine(ci.IsPrefix(s, "かごめ"))
+
    Console.WriteLine(ci.IsPrefix(s, "かこめ"))
+
    Console.WriteLine(ci.IsPrefix(s, "かこめ", CompareOptions.IgnoreNonSpace))
+

          
+
    Console.WriteLine()
+
    Console.WriteLine("IsSuffix(でやる、デヤル)")
+
    Console.WriteLine(s.EndsWith("でやる"))
+
    Console.WriteLine(s.EndsWith("デヤル"))
+
    Console.WriteLine(ci.IsSuffix(s, "でやる"))
+
    Console.WriteLine(ci.IsSuffix(s, "デヤル"))
+
    Console.WriteLine(ci.IsSuffix(s, "デヤル", CompareOptions.IgnoreKanaType))
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
+

          
+
#prompt{{
+
かごめかごめ かごのなかのとりは いついつでやる
 

        

        
+
IndexOf(とり、トリ)
+
13
+
-1
+
13
+
13
+
-1
+
13
+

          
+
LastIndexOf(かご、カゴ)
+
7
+
-1
+
7
+
-1
+
7
+

          
+
IsPrefix(かごめ、かこめ)
+
True
+
False
+
True
+
False
+
True
+

          
+
IsSuffix(でやる、デヤル)
+
True
+
False
+
True
+
False
+
True
+
}}
+

          
+
**CompareOptionsとソート
+
StringComparisonとは異なり、CompareOptionsに対応したIComparer<string>、IEqualityComparer<string>を提供するクラスはないため、自前で実装する必要があります。 例えば、キーのひらがなとカタカナの違いを無視するDictionary<string, string>を作成するには次のようにします。
+

          
+
#tabpage(C#)
+
#code(cs){{
+
using System;
+
using System.Collections.Generic;
+
using System.Globalization;
+

          
+
class IgnoreKanaTypeComparer : EqualityComparer<string>
+
{
+
  public override bool Equals(string x, string y)
+
  {
+
    return String.Compare(x, y, CultureInfo.InvariantCulture, CompareOptions.IgnoreKanaType) == 0;
+
  }
+

          
+
  public override int GetHashCode(string s)
+
  {
+
    return 0;
+
  }
+
}
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    Dictionary<string, string> dict = new Dictionary<string, string>(new IgnoreKanaTypeComparer());
+

          
+
    dict["ほげ"] = "hoge";
+
    dict["ぴよ"] = "piyo";
+
    dict["ふが"] = "fuga";
+

          
+
    dict["ピヨ"] = "PIYO";
+

          
+
    foreach (KeyValuePair<string, string> p in dict)
+
    {
+
      Console.WriteLine("{0} => {1}", p.Key, p.Value);
+
    }
+

          
+
    Console.WriteLine(dict.ContainsKey("ピヨ"));
+
  }
+
}
+
}}
+
#tabpage(VB)
 
#code(vb){{
#code(vb){{
~
Imports System
Module Module1
+
Imports System.Collections.Generic
+
Imports System.Globalization
+

          
+
Class IgnoreKanaTypeComparer
+
  Inherits EqualityComparer(Of String)
+

          
+
  Public Overrides Function Equals(ByVal x As String, ByVal y As String) As Boolean
+
    Return String.Compare(x, y, CultureInfo.InvariantCulture, CompareOptions.IgnoreKanaType) = 0
+
  End Function
+

          
+
  Public Overrides Function GetHashCode(ByVal s As String) As Integer
+
    Return 0
+
  End Function
+
End Class
+

          
+
Class Sample
+
  Shared Sub Main()
+
    Dim dict As New Dictionary(Of String, String)(New IgnoreKanaTypeComparer())
+

          
+
    dict("ほげ") = "hoge"
+
    dict("ぴよ") = "piyo"
+
    dict("ふが") = "fuga"
+

          
+
    dict("ピヨ") = "PIYO"
+

          
+
    For Each p As KeyValuePair(Of String, String) In dict
+
      Console.WriteLine("{0} => {1}", p.Key, p.Value)
+
    Next
+

          
+
    Console.WriteLine(dict.ContainsKey("ピヨ"))
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
+

          
+
#prompt{{
+
ほげ => hoge
+
ぴよ => PIYO
+
ふが => fuga
+
True
+
}}
+

          
+
この例では、&msdn(netfx,type,System.Collections.Generic.EqualityComparer){EqualityComparer<string>クラス};を継承することでIEqualityComparer<string>インターフェイスを実装しています。 また、GetHashCodeメソッドの実装は省略していますが、オブジェクトのハッシュ値が使用される場合は適切に実装する必要があります。
 

        

        
~
また、Array.SortやList<string>.Sortの場合は、IComparerを用意しなくてもComparison<string>に適合するメソッドがあれば良いので、次のようにできます。
    Sub Main()
 

        

        
~
#tabpage(C#)
        ' VB.NET の String型は .NET Framework の System.Stringクラスのエイリアス名
~
#code(cs){{
        Dim s1 As String
~
using System;
        Dim s2 As System.String
+
using System.Collections.Generic;
+
using System.Globalization;
 

        

        
~
class Sample
        ' s1に文字列を代入
~
{
        s1 = "sample string"
+
  static int CompareIgnoreWidth(string x, string y)
+
  {
+
    return String.Compare(x, y, CultureInfo.InvariantCulture, CompareOptions.IgnoreWidth);
+
  }
 

        

        
~
  static void Main()
        ' s1の参照を代入
~
  {
        s2 = s1
+
    string[] wordArray = new string[] {"foo", "Foo", "foo", "FOO", "FOO", "Foo"};
+
    List<string> wordList = new List<string>(wordArray);
 

        

        
~
    Console.WriteLine("List.Sort");
        Console.WriteLine("s1: {0}, s2: {1}, s1 is s2: {2}", s1, s2, s1 Is s2)
 

        

        
~
    Console.WriteLine("before sort                    : {0}", String.Join(", ", wordList.ToArray()));
        ' s1のコピーへの参照を代入
-
        s2 = String.Copy(s1)
 

        

        
~
    wordList.Sort(CompareIgnoreWidth);
        Console.WriteLine("s1: {0}, s2: {1}, s1 is s2: {2}", s1, s2, s1 Is s2)
 

        

        
~
    Console.WriteLine("CompareIgnoreWidth             : {0}", String.Join(", ", wordList.ToArray()));
        ' 文字列の連結
-
        s1 += " combined"
-
        ' s1 = s1 + " combined"
 

        

        
~
    wordList.Sort(StringComparer.InvariantCulture);
        Console.WriteLine(s1)
 

        

        
~
    Console.WriteLine("StringComparer.InvariantCulture: {0}", String.Join(", ", wordList.ToArray()));
        ' 文字列の挿入
-
        s2 = s2.Insert(6, " inserted")
 

        

        
~
    wordList.Sort(StringComparer.Ordinal);
        Console.WriteLine(s2)
 

        

        
~
    Console.WriteLine("StringComparer.Ordinal         : {0}", String.Join(", ", wordList.ToArray()));
        ' 文字列の削除
-
        s1 = s1.Remove(0, 7)
 

        

        
~
    Console.WriteLine("Array.Sort");
        Console.WriteLine(s1)
 

        

        
~
    Console.WriteLine("before sort                    : {0}", String.Join(", ", wordArray));
        ' 文字列の置き換え
-
        s2 = s2.Replace("sample", "test")
 

        

        
~
    Array.Sort(wordArray, CompareIgnoreWidth);
        Console.WriteLine(s2)
 

        

        
~
    Console.WriteLine("CompareIgnoreWidth             : {0}", String.Join(", ", wordArray));
    End Sub
 

        

        
~
    Array.Sort(wordArray, StringComparer.InvariantCulture);
End Module
+

          
+
    Console.WriteLine("StringComparer.InvariantCulture: {0}", String.Join(", ", wordArray));
+

          
+
    Array.Sort(wordArray, StringComparer.Ordinal);
+

          
+
    Console.WriteLine("StringComparer.Ordinal         : {0}", String.Join(", ", wordArray));
+
  }
+
}
 
}}
}}
+
#tabpage(VB)
+
#code(vb){{
+
Imports System
+
Imports System.Collections.Generic
+
Imports System.Globalization
 

        

        
~
Class Sample
#prompt(実行結果){{
~
  Shared Function CompareIgnoreWidth(ByVal x As String, ByVal y As String) As Integer
s1: sample string, s2: sample string, s1 is s2: True
~
    Return String.Compare(x, y, CultureInfo.InvariantCulture, CompareOptions.IgnoreWidth)
s1: sample string, s2: sample string, s1 is s2: False
~
  End Function
sample string combined
~

          
sample inserted string
~
  Shared Sub Main()
string combined
~
    Dim wordArray As String() = New String() {"foo", "Foo", "foo", "FOO", "FOO", "Foo"}
test inserted string
~
    Dim wordList As New List(Of String)(wordArray)
Press any key to continue
+

          
+
    Console.WriteLine("List.Sort")
+

          
+
    Console.WriteLine("before sort                    : {0}", String.Join(", ", wordList.ToArray()))
+

          
+
    wordList.Sort(AddressOf CompareIgnoreWidth)
+

          
+
    Console.WriteLine("CompareIgnoreWidth             : {0}", String.Join(", ", wordList.ToArray()))
+

          
+
    wordList.Sort(StringComparer.InvariantCulture)
+

          
+
    Console.WriteLine("StringComparer.InvariantCulture: {0}", String.Join(", ", wordList.ToArray()))
+

          
+
    wordList.Sort(StringComparer.Ordinal)
+

          
+
    Console.WriteLine("StringComparer.Ordinal         : {0}", String.Join(", ", wordList.ToArray()))
+

          
+
    Console.WriteLine("Array.Sort")
+

          
+
    Console.WriteLine("before sort                    : {0}", String.Join(", ", wordArray))
+

          
+
    Array.Sort(wordArray, AddressOf CompareIgnoreWidth)
+

          
+
    Console.WriteLine("CompareIgnoreWidth             : {0}", String.Join(", ", wordArray))
+

          
+
    Array.Sort(wordArray, StringComparer.InvariantCulture)
+

          
+
    Console.WriteLine("StringComparer.InvariantCulture: {0}", String.Join(", ", wordArray))
+

          
+
    Array.Sort(wordArray, StringComparer.Ordinal)
+

          
+
    Console.WriteLine("StringComparer.Ordinal         : {0}", String.Join(", ", wordArray))
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
+

          
+
#prompt{{
+
List.Sort
+
before sort                    : foo, Foo, foo, FOO, FOO, Foo
+
CompareIgnoreWidth             : foo, foo, Foo, Foo, FOO, FOO
+
StringComparer.InvariantCulture: foo, foo, Foo, FOO, Foo, FOO
+
StringComparer.Ordinal         : FOO, Foo, foo, FOO, Foo, foo
+
Array.Sort
+
before sort                    : foo, Foo, foo, FOO, FOO, Foo
+
CompareIgnoreWidth             : foo, foo, Foo, Foo, FOO, FOO
+
StringComparer.InvariantCulture: foo, foo, Foo, FOO, Foo, FOO
+
StringComparer.Ordinal         : FOO, Foo, foo, FOO, Foo, foo
 
}}
}}
 

        

        
~
#googleadunit
この例からわかるとおり、VBにおいて関数として存在していた挿入や置き換えがメソッドとして存在するようになったため、より簡単にコーディングできるようになりました。 もちろん、Microsoft.VisualBasic.Strings名前空間にある関数を使えば、VB同様に関数を用いて文字列操作を行うこともできます。 余談ですが、VB.NETでは文字列に対する複合代入演算子の使用がサポートされるようになったので、これを用いることで文字列連結が比較的簡単にできるようになりました。
+

          
+
----
 

        

        
 
*StringBuilderクラス
*StringBuilderクラス
~
.NET FrameworkのStringクラスはインスタンスの持つ値を変更できないという性質を持つ'''不変な'''型です。 Stringクラスの文字列操作では値が変わることは無く、操作の度に新しい文字列のインスタンスが生成されます。
ここまでは文字列型の簡単な操作方法を紹介しましたが、.NET FrameworkにはString型に似たクラスとしてStringBuilderクラスというものがあります。 次のコードは先ほどのコードを StringBuilderを用いたものにし、同様の実行結果を出力させるものです。
+
一方、&msdn(netfx,type,System.Text.StringBuilder){StringBuilderクラス};は内部にChar配列のバッファを保持し、文字列操作によってインスタンスの持つ値が変わる'''可変な'''型です。 StringBuilderクラスの文字列操作では、操作の際にバッファの内容は変更されますが、新しい文字列のインスタンスは生成されません。 文字列の挿入・削除・置換などの操作を繰り返す場合は、StringBuilderクラスを用いて行った方が適しています。
+

          
+
詳細な使い方は後述するとして、まずはStringクラスとStringBuilderクラスで同じ操作を行う場合の違いを見ておきます。
+

          
+
#tabpage(C#)
+
#code(cs){{
+
using System;
+
using System.Text;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    string s = "The quick brown fox jumps over the lazy dog";
+
    StringBuilder sb = new StringBuilder("The quick brown fox jumps over the lazy dog");
+

          
+
    Console.WriteLine("String       : {0}", s);
+
    Console.WriteLine("StringBuilder: {0}", sb);
+

          
+
    // 最後の8文字を削除
+
    s = s.Remove(s.Length - 8, 8);
+
    sb.Remove(sb.Length - 8, 8);
+

          
+
    Console.WriteLine("Remove");
+
    Console.WriteLine("String       : {0}", s);
+
    Console.WriteLine("StringBuilder: {0}", sb);
+

          
+
    // 文字列を追加
+
    s = s + "silliy dog";
+
    sb.Append("silliy dog");
+

          
+
    Console.WriteLine("Append");
+
    Console.WriteLine("String       : {0}", s);
+
    Console.WriteLine("StringBuilder: {0}", sb);
+

          
+
    // 文字列を置換
+
    s = s.Replace("The quick", "the clever");
+
    sb.Replace("The quick", "the clever");
+

          
+
    Console.WriteLine("Replace");
+
    Console.WriteLine("String       : {0}", s);
+
    Console.WriteLine("StringBuilder: {0}", sb);
+
  }
+
}
+
}}
+
#tabpage(VB)
+
#code(vb){{
+
Imports System
+
Imports System.Text
+

          
+
Class Sample
+
  Shared Sub Main()
+
    Dim s As String = "The quick brown fox jumps over the lazy dog"
+
    Dim sb As New StringBuilder("The quick brown fox jumps over the lazy dog")
+

          
+
    Console.WriteLine("String       : {0}", s)
+
    Console.WriteLine("StringBuilder: {0}", sb)
+

          
+
    ' 最後の8文字を削除
+
    s = s.Remove(s.Length - 8, 8)
+
    sb.Remove(sb.Length - 8, 8)
+

          
+
    Console.WriteLine("Remove")
+
    Console.WriteLine("String       : {0}", s)
+
    Console.WriteLine("StringBuilder: {0}", sb)
+

          
+
    ' 文字列を追加
+
    s = s + "silliy dog"
+
    sb.Append("silliy dog")
+

          
+
    Console.WriteLine("Append")
+
    Console.WriteLine("String       : {0}", s)
+
    Console.WriteLine("StringBuilder: {0}", sb)
+

          
+
    ' 文字列を置換
+
    s = s.Replace("The quick", "the clever")
+
    sb.Replace("The quick", "the clever")
+

          
+
    Console.WriteLine("Replace")
+
    Console.WriteLine("String       : {0}", s)
+
    Console.WriteLine("StringBuilder: {0}", sb)
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
+

          
+
#prompt{{
+
String       : The quick brown fox jumps over the lazy dog
+
StringBuilder: The quick brown fox jumps over the lazy dog
+
Remove
+
String       : The quick brown fox jumps over the 
+
StringBuilder: The quick brown fox jumps over the 
+
Append
+
String       : The quick brown fox jumps over the silliy dog
+
StringBuilder: The quick brown fox jumps over the silliy dog
+
Replace
+
String       : the clever brown fox jumps over the silliy dog
+
StringBuilder: the clever brown fox jumps over the silliy dog
+
}}
+

          
+
StringBuilderクラスの内容は、&msdn(netfx,method,System.Text.StringBuilder.ToString){StringBuilder.ToString};メソッドを使うことで通常の文字列として取得出来ます。
 

        

        
+
#tabpage(C#)
+
#code(cs){{
+
using System;
+
using System.Text;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    StringBuilder sb = new StringBuilder("The quick brown fox jumps");
+

          
+
    sb.Append(" over the lazy dog");
+

          
+
    string s = sb.ToString();
+

          
+
    Console.WriteLine(s);
+
  }
+
}
+
}}
+
#tabpage(VB)
 
#code(vb){{
#code(vb){{
+
Imports System
 
Imports System.Text
Imports System.Text
 

        

        
~
Class Sample
Module Module1
+
  Shared Sub Main()
+
    Dim sb As New StringBuilder("The quick brown fox jumps")
+

          
+
    sb.Append(" over the lazy dog")
+

          
+
    Dim s As String = sb.ToString()
+

          
+
    Console.WriteLine(s)
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
+

          
+
#prompt{{
+
The quick brown fox jumps over the lazy dog
+
}}
+

          
+
**文字列の結合 (Append, AppendLine, AppendFormat)
+
&msdn(netfx,method,System.Text.StringBuilder.Append){StringBuilder.Append};メソッドは、バッファに文字列を追加するメソッドで、String.Concatメソッドや加算演算子+による文字列の連結操作に相当します。 また、&msdn(netfx,method,System.Text.StringBuilder.AppendLine){StringBuilder.AppendLine};メソッドは、バッファに文字列を追加する点はAppendメソッドと同様ですが、自動的に末尾に改行文字も追加されます。 改行文字は常にEnvironment.NewLineが使われます。 &msdn(netfx,method,System.Text.StringBuilder.AppendFormat){StringBuilder.AppendFormat};メソッドは、指定された書式に整形してからバッファに追加するメソッドです。 String.Formatメソッドによる書式化と文字列の連結を同時に行う操作に相当します。
 

        

        
~
#tabpage(C#)
    Sub Main()
+
#code(cs){{
+
using System;
+
using System.Text;
 

        

        
~
class Sample
        ' StringBuilder は System.Text 名前空間のクラス
~
{
        Dim s1 As New StringBuilder("sample string")
~
  static void Main()
        Dim s2 As New StringBuilder("sample string")
+
  {
+
    StringBuilder sb = new StringBuilder(); // 空のStringBuilderを作成
 

        

        
~
    Console.WriteLine("<{0}>", sb);
        ' 文字列の連結
-
        s1.Append(" combined")
 

        

        
~
    // 文字列を追加
        Console.WriteLine(s1)
+
    sb.Append("The quick brown fox jumps");
 

        

        
~
    Console.WriteLine("<{0}>", sb);
        ' 文字列の挿入
-
        s2.Insert(6, " inserted")
 

        

        
~
    // 改行文字を付けて文字列を追加
        Console.WriteLine(s2)
+
    sb.AppendLine(" over the lazy dog");
 

        

        
~
    Console.WriteLine("<{0}>", sb);
        ' 文字列の削除
-
        s1.Remove(0, 7)
 

        

        
~
    // 文字列を追加
        Console.WriteLine(s1)
+
    sb.Append("The quick brown fox jumps");
 

        

        
~
    Console.WriteLine("<{0}>", sb);
        ' 文字列の置き換え
-
        s2.Replace("sample", "test")
 

        

        
~
    // 改行文字のみを追加
        Console.WriteLine(s2)
+
    sb.AppendLine();
 

        

        
~
    Console.WriteLine("<{0}>", sb);
    End Sub
 

        

        
~
    // 書式を指定し、数値を文字列化して追加
End Module
+
    sb.AppendFormat("{0:D} {0:D4} {0:N4}", 72);
+

          
+
    Console.WriteLine("<{0}>", sb);
+
  }
+
}
 
}}
}}
+
#tabpage(VB)
+
#code(vb){{
+
Imports System
+
Imports System.Text
 

        

        
~
Class Sample
#prompt(実行結果){{
~
  Shared Sub Main()
sample string combined
~
    Dim sb As New StringBuilder() ' 空のStringBuilderを作成
sample inserted string
~

          
string combined
~
    Console.WriteLine("<{0}>", sb)
test inserted string
~

          
Press any key to continue
+
    ' 文字列を追加
+
    sb.Append("The quick brown fox jumps")
+

          
+
    Console.WriteLine("<{0}>", sb)
+

          
+
    ' 改行文字を付けて文字列を追加
+
    sb.AppendLine(" over the lazy dog")
+

          
+
    Console.WriteLine("<{0}>", sb)
+

          
+
    ' 文字列を追加
+
    sb.Append("The quick brown fox jumps")
+

          
+
    Console.WriteLine("<{0}>", sb)
+

          
+
    ' 改行文字のみを追加
+
    sb.AppendLine()
+

          
+
    Console.WriteLine("<{0}>", sb)
+

          
+
    ' 書式を指定し、数値を文字列化して追加
+
    sb.AppendFormat("{0:D} {0:D4} {0:N4}", 72)
+

          
+
    Console.WriteLine("<{0}>", sb)
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
+

          
+
#prompt{{
+
<>
+
<The quick brown fox jumps>
+
<The quick brown fox jumps over the lazy dog
+
>
+
<The quick brown fox &msdn(netfx,method,System.Text.StringBuilder.Append){StringBuilder.Append};メソッド
+
jumps over the lazy dog
+
The quick brown fox jumps>
+
<The quick brown fox jumps over the lazy dog
+
The quick brown fox jumps
+
>
+
<The quick brown fox jumps over the lazy dog
+
The quick brown fox jumps
+
72 0072 72.0000>
 
}}
}}
 

        

        
~
AppendLineメソッドに引数を指定しなかった場合は、改行文字のみが追加されます。 先に述べたとおり、改行文字は常にEnvironment.NewLineが追加されるので、実行環境によって改行文字が変わると不都合がある困る場合や、CRまたはLFのみを追加したいといった場合は、Appendメソッドを使う必要があります。
まず、StringBuilderクラスのコンストラクタについて説明する必要があります。 このコンストラクタでは、文字列から StringBuilder型のインスタンスを作成しています。 このインスタンスは、内部的にこの文字列を保持し、各メソッドによってこの文字列を操作することができます。 このコードの実行結果を見てわかるとおり、メソッドの形式こそ違いますがString型の時と同じ出力結果になっています。 ここで注目していただきたいのは、String型のメソッドを用いた時にはその結果が必ず戻り値として返されていたのに対し、StringBuilder型を用いたときにはメソッドの結果がそのインスタンスに対してのみ及ぼされ戻り値を必要としていないことです。
+

          
+
AppendFormatメソッドでは任意の引数を書式化して追加することが出来ますが、Appendメソッドでも文字列以外の値を追加することが出来ます。 この場合、引数として指定された値は自動的に文字列化されてから追加されます。
+

          
+
#tabpage(C#)
+
#code(cs){{
+
using System;
+
using System.Text;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    StringBuilder sb = new StringBuilder(); // 空のStringBuilderを作成
 

        

        
~
    Console.WriteLine("<{0}>", sb);
これについて詳しく説明することにします。 実は、Stringクラスはその値を変更することができないという性質があります。 このことを「値が不変」であるといいます。 String型に関する文字列操作では値が変わったように見えますが、実は操作の際に新しいオブジェクトが作成されているのです。 そのため常に戻り値を取得する必要があったのです。 それに対してStringBuilderクラスはメソッドによってオブジェクトの値を変えることができます。 このことを「値が可変」であるといいます。 メソッドによる文字列操作の結果で戻り値を取る必要がなかったのはそのためです。
 

        

        
~
    // int型の数値を追加
**StringBuilderクラスの使用方法
~
    sb.Append(16);
StringBuilderクラスは内部的に文字列を保持した一種のバッファと考えることができます。 コンストラクタに何も指定しないでインスタンスを作成した場合、最大で16文字格納することができる空のStringBuilderが作成されます。 Append()メソッドによって文字列を追加していく際にこの最大文字数を超えると、インスタンスの容量は自動的に増やされます。 容量が増やされるような操作をしない限りは、メモリの再割り当てや解放等がされることはないので、高速に文字列を操作することができます。 さらに、ToString()メソッドを用いることで、StringBuilder の保持する文字列をString型に変換して取得することもできます。 次のコードでStringBuilderクラスに次々と文字列を追加していった際の容量の変化を見ることができます。
+
    sb.AppendLine();
 

        

        
+
    Console.WriteLine("<{0}>", sb);
+

          
+
    // double型の数値を追加
+
    sb.Append(Math.PI);
+
    sb.AppendLine();
+

          
+
    Console.WriteLine("<{0}>", sb);
+

          
+
    // bool型の値を追加
+
    sb.Append(true);
+
    sb.Append(false);
+
    sb.AppendLine();
+

          
+
    Console.WriteLine("<{0}>", sb);
+
  }
+
}
+
}}
+
#tabpage(VB)
 
#code(vb){{
#code(vb){{
+
Imports System
 
Imports System.Text
Imports System.Text
 

        

        
~
Class Sample
Module Module1
+
  Shared Sub Main()
+
    Dim sb As New StringBuilder() ' 空のStringBuilderを作成
+

          
+
    Console.WriteLine("<{0}>", sb)
+

          
+
    ' Integer型の数値を追加
+
    sb.Append(16)
+
    sb.AppendLine()
+

          
+
    Console.WriteLine("<{0}>", sb)
 

        

        
~
    ' Double型の数値を追加
    Sub Main()
+
    sb.Append(Math.PI)
+
    sb.AppendLine()
 

        

        
~
    Console.WriteLine("<{0}>", sb)
        ' 新しいインスタンスを作成
-
        Dim s As New StringBuilder()
 

        

        
~
    ' Boolean型の値を追加
        ' sの値を表示
~
    sb.Append(true)
        Console.WriteLine(s)
+
    sb.Append(false)
+
    sb.AppendLine()
 

        

        
~
    Console.WriteLine("<{0}>", sb)
        ' 現在の文字列の長さと、インスタンスの容量 (文字数)
~
  End Sub
        Console.WriteLine("Length: {0}, Capacity: {1}", s.Length, s.Capacity)
+
End Class
+
}}
+
#tabpage-end
+

          
+
#prompt{{
+
<>
+
<16
+
>
+
<16
+
3.14159265358979
+
>
+
<16
+
3.14159265358979
+
TrueFalse
+
>
+
}}
+

          
+
**文字列の挿入・削除・置換 (Insert, Remove, Replace)
+
Stringクラスと同様、文字列の挿入・削除・置換には&msdn(netfx,method,System.Text.StringBuilder.Insert){StringBuilder.Insert};、&msdn(netfx,method,System.Text.StringBuilder.Remove){StringBuilder.Remove};、&msdn(netfx,method,System.Text.StringBuilder.Replace){StringBuilder.Replace};の各メソッドが使えます。 引数と動作はStringクラスのものとほぼ同じですが、InsertメソッドはAppendメソッド同様に文字列以外も追加出来ます。 なお、String.Removeメソッドとは異なり、StringBuilder.Removeメソッドでは削除する文字数を省略することは出来ません。
+

          
+
#tabpage(C#)
+
#code(cs){{
+
using System;
+
using System.Text;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    StringBuilder sb = new StringBuilder("The quick brown fox jumps over the lazy dog");
+

          
+
    Console.WriteLine("<{0}>", sb);
+

          
+
    // 4文字目から6文字分を削除
+
    sb.Remove(4, 6);
 

        

        
~
    Console.WriteLine("<{0}>", sb);
        ' 10文字追加
-
        s.Append("1234567890")
 

        

        
~
    // 29文字目から4文字分を削除
        ' 表示
~
    sb.Remove(29, 4);
        Console.WriteLine(s)
 

        

        
~
    Console.WriteLine("<{0}>", sb);
        ' 現在の文字列の長さと、インスタンスの容量 (文字数)
-
        Console.WriteLine("Length: {0}, Capacity: {1}", s.Length, s.Capacity)
 

        

        
~
    // 29文字目に数値3を追加
        ' さらに10文字追加
~
    sb.Insert(29, 3);
        s.Append("1234567890")
 

        

        
~
    Console.WriteLine("<{0}>", sb);
        ' 表示
-
        Console.WriteLine(s)
 

        

        
~
    // 30文字目に" white "を追加
        ' 現在の文字列の長さと、インスタンスの容量 (文字数)
~
    sb.Insert(30, " white");
        Console.WriteLine("Length: {0}, Capacity: {1}", s.Length, s.Capacity)
 

        

        
~
    Console.WriteLine("<{0}>", sb);
    End Sub
 

        

        
~
    // 文字列"dog"を"dogs"に置換
End Module
+
    sb.Replace("dog", "dogs");
+

          
+
    Console.WriteLine("<{0}>", sb);
+

          
+
    // 文字'o'を'a'に置換
+
    sb.Replace('o', 'a');
+

          
+
    Console.WriteLine("<{0}>", sb);
+

          
+
    // 文字列"brawn"をnullに置換(=削除)
+
    sb.Replace("brawn ", null);
+

          
+
    Console.WriteLine("<{0}>", sb);
+
  }
+
}
 
}}
}}
+
#tabpage(VB)
+
#code(vb){{
+
Imports System
+
Imports System.Text
 

        

        
~
Class Sample
#prompt(実行結果){{
~
  Shared Sub Main()
Length: 0, Capacity: 16
~
    Dim sb As New StringBuilder("The quick brown fox jumps over the lazy dog")
1234567890
~

          
Length: 10, Capacity: 16
~
    Console.WriteLine("<{0}>", sb)
12345678901234567890
~

          
Length: 20, Capacity: 32
~
    ' 4文字目から6文字分を削除
Press any key to continue
+
    sb.Remove(4, 6)
+

          
+
    Console.WriteLine("<{0}>", sb)
+

          
+
    ' 29文字目から4文字分を削除
+
    sb.Remove(29, 4)
+

          
+
    Console.WriteLine("<{0}>", sb)
+

          
+
    ' 29文字目に数値3を追加
+
    sb.Insert(29, 3)
+

          
+
    Console.WriteLine("<{0}>", sb)
+

          
+
    ' 30文字目に" white "を追加
+
    sb.Insert(30, " white")
+

          
+
    Console.WriteLine("<{0}>", sb)
+

          
+
    ' 文字列"dog"を"dogs"に置換
+
    sb.Replace("dog", "dogs")
+

          
+
    Console.WriteLine("<{0}>", sb)
+

          
+
    ' 文字'o'を'a'に置換
+
    sb.Replace("o"c, "a"c)
+

          
+
    Console.WriteLine("<{0}>", sb)
+

          
+
    ' 文字列"brawn"をNothingに置換(=削除)
+
    sb.Replace("brawn ", Nothing)
+

          
+
    Console.WriteLine("<{0}>", sb)
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
+

          
+
#prompt{{
+
<The quick brown fox jumps over the lazy dog>
+
<The brown fox jumps over the lazy dog>
+
<The brown fox jumps over the  dog>
+
<The brown fox jumps over the 3 dog>
+
<The brown fox jumps over the 3 white dog>
+
<The brown fox jumps over the 3 white dogs>
+
<The brawn fax jumps aver the 3 white dags>
+
<The fax jumps aver the 3 white dags>
+
}}
+

          
+
***メソッドチェイン
+
Append, AppendFormat, AppendLine, Insert, Remove, Replaceの各メソッドは、戻り値としてインスタンス自身を返します。 これにより、stringクラスと同様にメソッドチェインを記述出来ます。
+

          
+
#tabpage(C#)
+
#code(cs){{
+
using System;
+
using System.Text;
+

          
+
class Sample
+
{
+
  static void Main()
+
  {
+
    string s = "The quick brown fox jumps over the lazy dog";
+
    StringBuilder sb = new StringBuilder("The quick brown fox jumps over the lazy dog");
+

          
+
    Console.WriteLine("String       : <{0}>", s);
+
    Console.WriteLine("StringBuilder: <{0}>", sb);
+

          
+
    s  =  s.Remove(4, 6).Remove(29, 4).Insert(29, "3").Insert(30, " white").Replace("dog", "dogs").Replace('o', 'a').Replace("brawn ", null);
+
    sb = sb.Remove(4, 6).Remove(29, 4).Insert(29,  3 ).Insert(30, " white").Replace("dog", "dogs").Replace('o', 'a').Replace("brawn ", null);
+

          
+
    Console.WriteLine("String       : <{0}>", s);
+
    Console.WriteLine("StringBuilder: <{0}>", sb);
+
  }
+
}
+
}}
+
#tabpage(VB)
+
#code(vb){{
+
Imports System
+
Imports System.Text
+

          
+
Class Sample
+
  Shared Sub Main()
+
    Dim s As String = "The quick brown fox jumps over the lazy dog"
+
    Dim sb As New StringBuilder("The quick brown fox jumps over the lazy dog")
+

          
+
    Console.WriteLine("String       : <{0}>", s)
+
    Console.WriteLine("StringBuilder: <{0}>", sb)
+

          
+
    s  =  s.Remove(4, 6).Remove(29, 4).Insert(29, "3").Insert(30, " white").Replace("dog", "dogs").Replace("o"c, "a"c).Replace("brawn ", Nothing)
+
    sb = sb.Remove(4, 6).Remove(29, 4).Insert(29,  3 ).Insert(30, " white").Replace("dog", "dogs").Replace("o"c, "a"c).Replace("brawn ", Nothing)
+

          
+
    Console.WriteLine("String       : <{0}>", s)
+
    Console.WriteLine("StringBuilder: <{0}>", sb)
+
  End Sub
+
End Class
 
}}
}}
+
#tabpage-end
+

          
+
#prompt{{
+
Stri