2011-12-14T01:42:57の更新内容

programming/tips/check_issubclassof/index.wiki.txt

current previous
1,9 1,9
~
${smdncms:title,型情報から派生クラスかどうかを調べる}
${smdncms:title,型があるクラスの派生クラスであるかを調べる}
~
${smdncms:keywords,VB.NET,C#,IsSubclassOf,IsAssignableFrom,Type,型,派生クラス}
${smdncms:keywords,VB.NET,C#,IsSubclassOf,Type,派生クラス}
 
${smdncms:tags,api/.net,lang/vb,lang/c#}
${smdncms:tags,api/.net,lang/vb,lang/c#}
 
${smdncms:document_versions,codelang=cs,codelang=vb}
${smdncms:document_versions,codelang=cs,codelang=vb}
 

        

        
~
&msdn(netfx,type,System.Type){Typeクラス};の&msdn(netfx,member,System.Type.IsSubclassOf){IsSubclassOfメソッド};を使うことで、型情報から型があるクラスから派生するものかどうかを判定できる。 ただし、このメソッドでは同じ型を表す場合はFalseを返される点に注意が必要で、同じクラスを表すかどうかを判定する場合は、&msdn(netfx,member,System.Type.Equals){Type.Equalsメソッド};もしくはis演算子(C#)やIs演算子(VB.NET)を使って判定する必要がある。
TypeクラスのIsSubclassOf()メソッドを使うことで、型があるクラスの派生クラスであるかどうかを判定できる。 ただし、このメソッドでは同じクラスを表す場合はFalseを返されるので、同じクラスを表すかどうかを判定する場合は、is演算子(C#)やIs演算子(VB.NET)を使って判定する必要がある。 
 

        

        
 
-関連するページ
-関連するページ
 
--[[programming/tips/plugin_assembly]]
--[[programming/tips/plugin_assembly]]
12,158 12,71
 

        

        
 
#tabpage(C#)
#tabpage(C#)
 
#code(cs){{
#code(cs){{
~
using System;
public class ClassA {}
 

        

        
~
class Base {}
public class ClassB : ClassA {}
~
class Class1 : Base {}

          
~
class Class2 : Class1 {}
public class ClassC : ClassB {}
~
class Class3 {}

          
~

          
public class Test
~
class Sample {
{
~
  public static void Main()
    public static void Main()
~
  {
    {
~
    Type typeOfBase = typeof(Base);
        Type typeOfClassA = typeof( ClassA );
~
    Type typeOfClass1 = typeof(Class1);
        Type typeOfClassB = typeof( ClassB );
~
    Type typeOfClass2 = typeof(Class2);
        Type typeOfClassC = typeof( ClassC );
~
    Type typeOfClass3 = typeof(Class3);

          
~

          
        if ( typeOfClassA.IsSubclassOf( typeOfClassB ) ) Console.WriteLine( "{0}は{1}の派生クラスです。", typeOfClassA.Name, typeOfClassB.Name );
~
    Console.WriteLine("{0}.IsSubclassOf({1}) = {2}", typeOfClass1, typeOfBase, typeOfClass1.IsSubclassOf(typeOfBase));
        if ( typeOfClassB.IsSubclassOf( typeOfClassA ) ) Console.WriteLine( "{0}は{1}の派生クラスです。", typeOfClassB.Name, typeOfClassA.Name );
~
    Console.WriteLine("{0}.IsSubclassOf({1}) = {2}", typeOfClass2, typeOfBase, typeOfClass2.IsSubclassOf(typeOfBase));

          
~
    Console.WriteLine("{0}.IsSubclassOf({1}) = {2}", typeOfClass3, typeOfBase, typeOfBase.IsSubclassOf(typeOfClass1));
        if ( typeOfClassC.IsSubclassOf( typeOfClassA ) ) Console.WriteLine( "{0}は{1}の派生クラスです。", typeOfClassC.Name, typeOfClassA.Name );
~
    Console.WriteLine("{0}.IsSubclassOf({1}) = {2}", typeOfBase, typeOfClass1, typeOfBase.IsSubclassOf(typeOfClass1));
        if ( typeOfClassC.IsSubclassOf( typeOfClassB ) ) Console.WriteLine( "{0}は{1}の派生クラスです。", typeOfClassC.Name, typeOfClassB.Name );
~
    Console.WriteLine("{0}.IsSubclassOf({1}) = {2}", typeOfBase, typeOfBase, typeOfBase.IsSubclassOf(typeOfBase));
        if ( typeOfClassC.IsSubclassOf( typeOfClassC ) ) Console.WriteLine( "{0}は{1}の派生クラスです。", typeOfClassC.Name, typeOfClassC.Name );
~
  }
    }
 
}
}
 
}}
}}
 
#tabpage(VB)
#tabpage(VB)
 
#code(vb){{
#code(vb){{
~
Imports System
Public Class ClassA
 

        

        
+
Class Base : End Class
+
Class Class1 : Inherits Base : End Class
+
Class Class2 : Inherits Class1 : End Class
+
Class Class3 : End Class
+

          
+
Class Sample
+
  Public Shared Sub Main()
+
    Dim typeOfBase As Type = GetType(Base)
+
    Dim typeOfClass1 As Type = GetType(Class1)
+
    Dim typeOfClass2 As Type = GetType(Class2)
+
    Dim typeOfClass3 As Type = GetType(Class3)
+

          
+
    Console.WriteLine("{0}.IsSubclassOf({1}) = {2}", typeOfClass1, typeOfBase, typeOfClass1.IsSubclassOf(typeOfBase))
+
    Console.WriteLine("{0}.IsSubclassOf({1}) = {2}", typeOfClass2, typeOfBase, typeOfClass2.IsSubclassOf(typeOfBase))
+
    Console.WriteLine("{0}.IsSubclassOf({1}) = {2}", typeOfClass3, typeOfBase, typeOfBase.IsSubclassOf(typeOfClass1))
+
    Console.WriteLine("{0}.IsSubclassOf({1}) = {2}", typeOfBase, typeOfClass1, typeOfBase.IsSubclassOf(typeOfClass1))
+
    Console.WriteLine("{0}.IsSubclassOf({1}) = {2}", typeOfBase, typeOfBase, typeOfBase.IsSubclassOf(typeOfBase))
+
  End Sub
 
End Class
End Class
+
}}
+
#tabpage-end
 

        

        
~
#prompt(実行結果){{
Public Class ClassB
~
Class1.IsSubclassOf(Base) = True

          
~
Class2.IsSubclassOf(Base) = True
    Inherits ClassA
+
Class3.IsSubclassOf(Base) = False
+
Base.IsSubclassOf(Class1) = False
+
Base.IsSubclassOf(Base) = False
+
}}
 

        

        
~
継承関係ではなく実装しているインターフェイスなど、型が別の型に''代入可能かどうか''を判定したい場合は&msdn(netfx,member,System.Type.IsAssignableFrom){IsAssignableFromメソッド};を使って調べることが出来る。
End Class
 

        

        
~
#tabpage(C#)
Public Class ClassC
+
#code(cs){{
+
using System;
 

        

        
~
interface IIfc1 {}
    Inherits ClassB
+
interface IIfc2 {}
+
class Class1 : IIfc1 {}
+
class Class2 : IIfc2 {}
+
class Class3 : Class1, IIfc2 {}
+

          
+
class Sample {
+
  public static void Main()
+
  {
+
    Type typeOfIfc1 = typeof(IIfc1);
+
    Type typeOfIfc2 = typeof(IIfc2);
+
    Type typeOfClass1 = typeof(Class1);
+
    Type typeOfClass2 = typeof(Class2);
+
    Type typeOfClass3 = typeof(Class3);
+

          
+
    Console.WriteLine("{0}.IsAssignableFrom({1}) = {2}", typeOfIfc1, typeOfClass1, typeOfIfc1.IsAssignableFrom(typeOfClass1));
+
    Console.WriteLine("{0}.IsAssignableFrom({1}) = {2}", typeOfIfc2, typeOfClass1, typeOfIfc2.IsAssignableFrom(typeOfClass1));
+
    Console.WriteLine();
+

          
+
    Console.WriteLine("{0}.IsAssignableFrom({1}) = {2}", typeOfIfc1, typeOfClass2, typeOfIfc1.IsAssignableFrom(typeOfClass2));
+
    Console.WriteLine("{0}.IsAssignableFrom({1}) = {2}", typeOfIfc2, typeOfClass2, typeOfIfc2.IsAssignableFrom(typeOfClass2));
+
    Console.WriteLine();
+

          
+
    Console.WriteLine("{0}.IsAssignableFrom({1}) = {2}", typeOfIfc1, typeOfClass3, typeOfIfc1.IsAssignableFrom(typeOfClass3));
+
    Console.WriteLine("{0}.IsAssignableFrom({1}) = {2}", typeOfIfc2, typeOfClass3, typeOfIfc2.IsAssignableFrom(typeOfClass3));
+
    Console.WriteLine();
+

          
+
    Console.WriteLine("{0}.IsSubclassOf({1}) = {2}", typeOfClass3, typeOfClass1, typeOfClass3.IsSubclassOf(typeOfClass1));
+
    Console.WriteLine("{0}.IsSubclassOf({1}) = {2}", typeOfClass3, typeOfIfc1, typeOfClass3.IsSubclassOf(typeOfIfc1));
+
    Console.WriteLine("{0}.IsAssignableFrom({1}) = {2}", typeOfIfc1, typeOfClass3, typeOfIfc1.IsAssignableFrom(typeOfClass3));
+
    Console.WriteLine("{0}.IsAssignableFrom({1}) = {2}", typeOfIfc2, typeOfClass3, typeOfIfc2.IsAssignableFrom(typeOfClass3));
+
    Console.WriteLine("{0}.IsAssignableFrom({1}) = {2}", typeOfClass1, typeOfClass3, typeOfClass1.IsAssignableFrom(typeOfClass3));
+
  }
+
}
+
}}
+
#tabpage(VB)
+
#code(vb){{
+
Imports System
 

        

        
+
Interface IIfc1 : End Interface
+
Interface IIfc2 : End Interface
+
Class Class1 : Implements IIfc1 : End Class
+
Class Class2 : Implements IIfc2 : End Class
+
Class Class3 : Inherits Class1 : Implements IIfc2 : End Class
+

          
+
Class Sample
+
  Public Shared Sub Main()
+
    Dim typeOfIfc1 As Type = GetType(IIfc1)
+
    Dim typeOfIfc2 As Type = GetType(IIfc2)
+
    Dim typeOfClass1 As Type = GetType(Class1)
+
    Dim typeOfClass2 As Type = GetType(Class2)
+
    Dim typeOfClass3 As Type = GetType(Class3)
+

          
+
    Console.WriteLine("{0}.IsAssignableFrom({1}) = {2}", typeOfIfc1, typeOfClass1, typeOfIfc1.IsAssignableFrom(typeOfClass1))
+
    Console.WriteLine("{0}.IsAssignableFrom({1}) = {2}", typeOfIfc2, typeOfClass1, typeOfIfc2.IsAssignableFrom(typeOfClass1))
+
    Console.WriteLine()
+

          
+
    Console.WriteLine("{0}.IsAssignableFrom({1}) = {2}", typeOfIfc1, typeOfClass2, typeOfIfc1.IsAssignableFrom(typeOfClass2))
+
    Console.WriteLine("{0}.IsAssignableFrom({1}) = {2}", typeOfIfc2, typeOfClass2, typeOfIfc2.IsAssignableFrom(typeOfClass2))
+
    Console.WriteLine()
+

          
+
    Console.WriteLine("{0}.IsAssignableFrom({1}) = {2}", typeOfIfc1, typeOfClass3, typeOfIfc1.IsAssignableFrom(typeOfClass3))
+
    Console.WriteLine("{0}.IsAssignableFrom({1}) = {2}", typeOfIfc2, typeOfClass3, typeOfIfc2.IsAssignableFrom(typeOfClass3))
+
    Console.WriteLine()
+

          
+
    Console.WriteLine("{0}.IsSubclassOf({1}) = {2}", typeOfClass3, typeOfClass1, typeOfClass3.IsSubclassOf(typeOfClass1))
+
    Console.WriteLine("{0}.IsSubclassOf({1}) = {2}", typeOfClass3, typeOfIfc1, typeOfClass3.IsSubclassOf(typeOfIfc1))
+
    Console.WriteLine("{0}.IsAssignableFrom({1}) = {2}", typeOfIfc1, typeOfClass3, typeOfIfc1.IsAssignableFrom(typeOfClass3))
+
    Console.WriteLine("{0}.IsAssignableFrom({1}) = {2}", typeOfIfc2, typeOfClass3, typeOfIfc2.IsAssignableFrom(typeOfClass3))
+
    Console.WriteLine("{0}.IsAssignableFrom({1}) = {2}", typeOfClass1, typeOfClass3, typeOfClass1.IsAssignableFrom(typeOfClass3))
+
  End Sub
 
End Class
End Class
+
}}
+
#tabpage-end
 

        

        
~
#prompt(実行結果){{
Public Class Test
~
IIfc1.IsAssignableFrom(Class1) = True

          
~
IIfc2.IsAssignableFrom(Class1) = False
    Public Shared Sub Main()
-

          
-
        Dim typeOfClassA As Type = GetType(ClassA)
-
        Dim typeOfClassB As Type = GetType(ClassB)
-
        Dim typeOfClassC As Type = GetType(ClassC)
-

          
-
        If typeOfClassA.IsSubclassOf(typeOfClassB) Then Console.WriteLine("{0}は{1}の派生クラスです。", typeOfClassA.Name, typeOfClassB.Name)
-
        If typeOfClassB.IsSubclassOf(typeOfClassA) Then Console.WriteLine("{0}は{1}の派生クラスです。", typeOfClassB.Name, typeOfClassA.Name)
 

        

        
~
IIfc1.IsAssignableFrom(Class2) = False
        If typeOfClassC.IsSubclassOf(typeOfClassA) Then Console.WriteLine("{0}は{1}の派生クラスです。", typeOfClassC.Name, typeOfClassA.Name)
~
IIfc2.IsAssignableFrom(Class2) = True
        If typeOfClassC.IsSubclassOf(typeOfClassB) Then Console.WriteLine("{0}は{1}の派生クラスです。", typeOfClassC.Name, typeOfClassB.Name)
-
        If typeOfClassC.IsSubclassOf(typeOfClassC) Then Console.WriteLine("{0}は{1}の派生クラスです。", typeOfClassC.Name, typeOfClassC.Name)
 

        

        
~
IIfc1.IsAssignableFrom(Class3) = True
    End Sub
+
IIfc2.IsAssignableFrom(Class3) = True
 

        

        
~
Class3.IsSubclassOf(Class1) = True
End Class
+
Class3.IsSubclassOf(IIfc1) = False
+
IIfc1.IsAssignableFrom(Class3) = True
+
IIfc2.IsAssignableFrom(Class3) = True
+
Class1.IsAssignableFrom(Class3) = True
 
}}
}}
-
#tabpage-end
 

        

        
-
#prompt(実行結果){{
-
ClassBはClassAの派生クラスです。
-
ClassCはClassAの派生クラスです。
-
ClassCはClassBの派生クラスです。
-
Press any key to continue
-
}}

programming/tips/calc_textbytecount/index.wiki.txt

current previous
1,104 0,0
+
${smdncms:title,文字・文字列のバイト数を調べる}
+
${smdncms:keywords,VB.NET,C#,文字,文字列,バイト数,Encoding,GetByteCount,1バイト文字,2バイト文字}
+
${smdncms:tags,api/.net,lang/vb,lang/c#}
+
${smdncms:document_versions,codelang=cs,codelang=vb}
+

          
+
-関連するページ
+
--[[programming/tips/shiftjis_eucjp]]
+
--[[programming/tips/check_ngchar]]
+

          
+
#googleadunit
+

          
+
&msdn(netfx,member,System.Text.Encoding.GetByteCount){Encoding.GetByteCountメソッド};を使うことで文字列を任意の文字コードにエンコードしたときのバイト数を取得出来る。
+

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

          
+
class Sample {
+
  public static void Main()
+
  {
+
    string s = "ABCアイウあいう漢字";
+
    Encoding e = Encoding.GetEncoding("shift_jis");
+

          
+
    Console.WriteLine("Length = {0}", s.Length);
+
    Console.WriteLine("ByteCount = {0}", e.GetByteCount(s));
+
  }
+
}
+
}}
+
#tabpage(VB)
+
#code(vb){{
+
Imports System
+
Imports System.Text
+

          
+
Class Sample
+
  Public Shared Sub Main()
+
    Dim s As String = "ABCアイウあいう漢字"
+
    Dim e As Encoding = Encoding.GetEncoding("shift_jis")
+

          
+
    Console.WriteLine("Length = {0}", s.Length)
+
    Console.WriteLine("ByteCount = {0}", e.GetByteCount(s))
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
+

          
+
#prompt(実行結果){{
+
Length = 11
+
ByteCount = 16
+
}}
+

          
+
文字ごとに1バイト文字か2バイト文字かを調べるためのメソッドは無いため、&msdn(netfx,member,System.Text.Encoding.GetByteCount){Encoding.GetByteCountメソッド};を使って調べるには、&msdn(netfx,member,System.String.Substring){String.Substringメソッド};で一文字ずつ切り出して調べるか、いったんchar配列に変換して調べる必要がある。
+

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

          
+
class Sample {
+
  public static void Main()
+
  {
+
    string s = "ABCアイウあいう漢字";
+
    char[] chars = s.ToCharArray();
+
    Encoding e = Encoding.GetEncoding("shift_jis");
+

          
+
    for (int index = 0; index < chars.Length; index++) {
+
      Console.WriteLine("'{0}' - {1} byte(s)", chars[index], e.GetByteCount(chars, index, 1));
+
    }
+
  }
+
}
+
}}
+
#tabpage(VB)
+
#code(vb){{
+
Imports System
+
Imports System.Text
+

          
+
Class Sample
+
  Public Shared Sub Main()
+
    Dim s As String = "ABCアイウあいう漢字"
+
    Dim chars() As Char = s.ToCharArray()
+
    Dim e As Encoding = Encoding.GetEncoding("shift_jis")
+

          
+
    For index As Integer = 0 To chars.Length - 1
+
      Console.WriteLine("'{0}' - {1} byte(s)", chars(index), e.GetByteCount(chars, index, 1))
+
    Next
+
  End Sub
+
End Class
+
}}
+
#tabpage-end
+

          
+
#prompt(実行結果){{
+
'A' - 1 byte(s)
+
'B' - 1 byte(s)
+
'C' - 1 byte(s)
+
'ア' - 1 byte(s)
+
'イ' - 1 byte(s)
+
'ウ' - 1 byte(s)
+
'あ' - 2 byte(s)
+
'い' - 2 byte(s)
+
'う' - 2 byte(s)
+
'漢' - 2 byte(s)
+
'字' - 2 byte(s)
+
}}
+

          

programming/tips/get_hinstance/index.wiki.txt

current previous
1,9 1,9
 
${smdncms:title,アプリケーションのインスタンスハンドルを取得する}
${smdncms:title,アプリケーションのインスタンスハンドルを取得する}
~
${smdncms:keywords,C#,VB.NET,HINSTANCE,Marshal.GetHINSTANCE,インスタンスハンドル}
${smdncms:keywords,C#,VB.NET,HINSTANCE}
 
${smdncms:tags,plat/win,api/.net,lang/c#,lang/vb}
${smdncms:tags,plat/win,api/.net,lang/c#,lang/vb}
 
${smdncms:document_versions,codelang=cs,codelang=vb}
${smdncms:document_versions,codelang=cs,codelang=vb}
 

        

        
~
アプリケーション・プロセスのインスタンスハンドル(HINSTANCE)を取得するには、現在実行しているアセンブリに含まれるモジュールからHINSTANCEを取得する。 モジュールからHINSTANCEを取得するには&msdn(netfx,member,System.Runtime.InteropServices.Marshal.GetHINSTANCE){Marshal.GetHINSTANCE};メソッドを使用する。
現在実行しているアセンブリに含まれるモジュールからhInstanceを取得する方法。 モジュールのhInstanceを取得するにはMarshal.GetHINSTANCE()メソッドを使用する。 
 

        

        
 
-関連するページ
-関連するページ
 
--[[programming/tips/extractassociatedicon]]
--[[programming/tips/extractassociatedicon]]
12,51 12,32
 

        

        
 
#tabpage(C#)
#tabpage(C#)
 
#code(cs){{
#code(cs){{
~
using System;
public static void Main()
~
using System.Reflection;
{
~
using System.Runtime.InteropServices;
    IntPtr hInstance;
+

          
+
class Sample {
+
  public static IntPtr GetHInstance()
+
  {
+
    // 現在実行しているアセンブリからモジュールを取得
+
    Module mod = Assembly.GetExecutingAssembly().GetModules()[0];
+

          
+
    // モジュールのHINSTANCEを取得
+
    return Marshal.GetHINSTANCE(mod);
+
  }
+

          
+
  public static void Main()
+
  {
+
    IntPtr hInstance = GetHInstance();
 

        

        
~
    Console.WriteLine(hInstance);
    hInstance = GetHInstance();
~
  }
}
-

          
-
public static IntPtr GetHInstance()
-
{
-
    return Marshal.GetHINSTANCE( Assembly.GetExecutingAssembly().GetModules()[0] );
 
}
}
 
}}
}}
 
#tabpage(VB)
#tabpage(VB)
 
#code(vb){{
#code(vb){{
~
Imports System
Public Shared Sub Main()
~
Imports System.Reflection

          
~
Imports System.Runtime.InteropServices
    Dim hInstance As IntPtr
~

          

          
~
Class Sample
    hInstance = GetHInstance()
~
  Public Shared Function GetHInstance() As IntPtr

          
~
    ' 現在実行しているアセンブリからモジュールを取得
End Sub
~
    Dim m As [Module] = Assembly.GetExecutingAssembly().GetModules()(0)

          
~

          
Public Shared Function GetHInstance() As IntPtr
~
    ' モジュールのHINSTANCEを取得

          
~
    Return Marshal.GetHINSTANCE(m)
    Return Marshal.GetHINSTANCE([Assembly].GetExecutingAssembly().GetModules()(0))
~
  End Function

          
~

          
End Function
+
  Public Shared Sub Main()
+
    Dim hInstance As IntPtr = GetHInstance()
+

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

          
+
なお、Visual StudioのデバッグオプションでVisual Studioホスティングプロセスを有効にしている場合は、ホスティングプロセス(*.vshost.exe)のHINSTANCEが取得される(?)ため、HINSTANCEを使ったAPI呼び出し等が失敗する。 これを回避するには、Visual Studioホスティングプロセスを無効にするか、*.vshost.exeではなく直接*.exeを実行する必要がある。
+

          

programming/tips/enumwindows/index.wiki.txt

current previous
1,9 1,9
 
${smdncms:title,表示されているウィンドウを列挙する}
${smdncms:title,表示されているウィンドウを列挙する}
~
${smdncms:keywords,C#,VB.NET,EnumWindows,IsWindowVisible,GetWindowText,GetWindowThreadProcessId,Process.GetProcessById,すべてのウィンドウ}
${smdncms:keywords,C#,VB.NET,EnumWindows,IsWindowVisible}
 
${smdncms:tags,plat/win,api/win32,lang/c#,lang/vb}
${smdncms:tags,plat/win,api/win32,lang/c#,lang/vb}
 
${smdncms:document_versions,codelang=cs,codelang=vb}
${smdncms:document_versions,codelang=cs,codelang=vb}
 

        

        
~
API関数のEnumWindowsを使うことで、全てのウィンドウのハンドル(HWND)を取得する事ができる。 EnumWindowsを呼び出すと、コールバックメソッドが呼び出され、存在する個々のウィンドウのHWNDが渡される。
API関数のEnumWindows()及びコールバックメソッド用デリゲートを使うことで、全てのウィンドウを列挙する事ができる。 また、列挙に際してIsWindowVisible() API関数を同時に用いることで可視ウィンドウだけを列挙することができる。
 

        

        
 
-関連するページ
-関連するページ
 
--[[programming/tips/disable_alt_f4]]
--[[programming/tips/disable_alt_f4]]
14,150 14,141
 

        

        
 
#googleadunit
#googleadunit
 

        

        
+
以下の例では、EnumWindows()でウィンドウを列挙し、コールバックメソッド内ではIsWindowVisible()を使って可視ウィンドウかどうかを調べている。 また、個々の可視ウィンドウについて、GetWindowText()を使ってウィンドウのキャプションを、GetWindowThreadProcessId()と&msdn(netfx,member,System.Diagnostics.Process.GetProcessById){Process.GetProcessById};を使ってプロセス情報を取得・表示している。
+

          
 
#tabpage(C#)
#tabpage(C#)
 
#code(cs){{
#code(cs){{
 
using System;
using System;
~
using System.Diagnostics;
using System.Text;
 
using System.Runtime.InteropServices;
using System.Runtime.InteropServices;
+
using System.Text;
 

        

        
~
class Sample {
class EmumerateWindows
~
  [DllImport("user32")]
{
~
  private static extern bool EnumWindows(WNDENUMPROC lpEnumFunc, IntPtr lParam);
    // コールバックメソッドのデリゲート
-
    private delegate int EnumerateWindowsCallback( IntPtr hWnd, int lParam );
-

          
-
    // EnumWindows API関数の宣言
-
    [DllImport( "user32", EntryPoint = "EnumWindows" )]
-
    private static extern int EnumWindows( EnumerateWindowsCallback lpEnumFunc, int lParam );
-

          
-
    // GetWindowText API関数の宣言
-
    [DllImport( "user32", EntryPoint = "GetWindowText", CharSet = CharSet.Auto )]
-
    private static extern int GetWindowText( IntPtr hWnd, StringBuilder lpString, int nMaxCount );
-

          
-
    // IsWindowVisible API関数の宣言
-
    [DllImport( "user32", EntryPoint = "IsWindowVisible" )]
-
    private static extern int IsWindowVisible( IntPtr hWnd );
-

          
-
    // ウィンドウを列挙するためのコールバックメソッド
-
    public static int EnumerateWindows( IntPtr hWnd, int lParam )
-
    {
-
        StringBuilder sb = new StringBuilder( 0x1000);
-

          
-
        // ウィンドウが可視の場合
-
        if ( IsWindowVisible( hWnd ) != 0 ) 
-
        {
-
            // ウィンドウのキャプションを取得
-
            if ( GetWindowText( hWnd , sb , 0x1000 ) != 0 ) 
-
            {
-
                // 取得できたキャプションを表示
-
                Console.WriteLine( sb.ToString());
-
            }
-
        }
-

          
-
        // 列挙を継続するには0以外を返す必要がある
-
        return 1;
-
    }
-

          
-
    // Mainメソッド
-
    [STAThread]
-
    public static void Main()
-
    {
-
        // 列挙を開始
-
        EnumWindows( new EnumerateWindowsCallback( EnumerateWindows ), 0 );
-
    }
-
}
-
}}
-
#tabpage(VB)
-
#code(vb){{
-
Option Strict On
-

          
-
Imports System
-
Imports System.Text
-
Imports System.Runtime.InteropServices
-

          
-
Class EmumerateWindows
-

          
-
    ' コールバックメソッドのデリゲート
-
    Private Delegate Function EnumerateWindowsCallback(ByVal hWnd As IntPtr, ByVal lParam As Integer) As Integer
-

          
-
    ' EnumWindows API関数の宣言
-
    <DllImport("user32", EntryPoint:="EnumWindows")> _
-
    Private Shared Function EnumWindows( _
-
        ByVal lpEnumFunc As EnumerateWindowsCallback, _
-
        ByVal lParam As Integer) _
-
        As Integer
-
    End Function
 

        

        
~
  // EnumWindowsから呼び出されるコールバック関数WNDENUMPROCのデリゲート
    ' GetWindowText API関数の宣言
~
  private delegate bool WNDENUMPROC(IntPtr hWnd, IntPtr lParam);
    <DllImport("user32", EntryPoint:="GetWindowText", CharSet:=CharSet.Auto)> _
-
    Private Shared Function GetWindowText( _
-
        ByVal hWnd As IntPtr, _
-
        ByVal lpString As StringBuilder, _
-
        ByVal nMaxCount As Integer) _
-
        As Integer
-
    End Function
 

        

        
~
  [DllImport("user32")]
    ' IsWindowVisible API関数の宣言
~
  private static extern bool IsWindowVisible(IntPtr hWnd);
    <DllImport("user32", EntryPoint:="IsWindowVisible")> _
-
    Private Shared Function IsWindowVisible( _
-
        ByVal hWnd As IntPtr) _
-
        As Integer
-
    End Function
 

        

        
~
  [DllImport("user32", CharSet = CharSet.Auto)]
    ' ウィンドウを列挙するためのコールバックメソッド
~
  private static extern int GetWindowText(IntPtr hWnd, StringBuilder lpString, int nMaxCount);
    Public Shared Function EnumerateWindows(ByVal hWnd As IntPtr, ByVal lParam As Integer) As Integer
 

        

        
~
  [DllImport("user32")]
        Dim sb As New StringBuilder(&H1000)
+
  private static extern int GetWindowThreadProcessId(IntPtr hWnd, out int lpdwProcessId);
 

        

        
~
  public static void Main()
        ' ウィンドウが可視の場合
~
  {
        If IsWindowVisible(hWnd) <> 0 Then
+
    // ウィンドウの列挙を開始
+
    EnumWindows(EnumerateWindow, IntPtr.Zero);
+
  }
 

        

        
~
  // ウィンドウを列挙するためのコールバックメソッド
            ' ウィンドウのキャプションを取得
~
  private static bool EnumerateWindow(IntPtr hWnd, IntPtr lParam)
            If GetWindowText(hWnd, sb, &H1000) <> 0 Then
+
  {
+
    // ウィンドウが可視かどうか調べる
+
    if (IsWindowVisible(hWnd))
+
      // 可視の場合
+
      PrintCaptionAndProcess(hWnd);
 

        

        
~
    // ウィンドウの列挙を継続するにはtrueを返す必要がある
                ' 取得できたキャプションを表示
~
    return true;
                Console.WriteLine(sb.ToString())
+
  }
 

        

        
~
  // ウィンドウのキャプションとプロセス名を表示する
            End If
+
  private static void PrintCaptionAndProcess(IntPtr hWnd)
+
  {
+
    // ウィンドウのキャプションを取得・表示
+
    StringBuilder caption = new StringBuilder(0x1000);
 

        

        
~
    GetWindowText(hWnd, caption, caption.Capacity);
        End If
 

        

        
~
    Console.Write("'{0}' ", caption);
        ' 列挙を継続するには0以外を返す必要がある
-
        Return Not 0
 

        

        
~
    // ウィンドウハンドルからプロセスIDを取得
    End Function
+
    int processId;
 

        

        
~
    GetWindowThreadProcessId(hWnd, out processId);
    ' Mainメソッド
-
    Public Shared Sub Main()
 

        

        
~
    // プロセスIDからProcessクラスのインスタンスを取得
        ' 列挙を開始
~
    Process p = Process.GetProcessById(processId);
        EnumWindows(AddressOf EnumerateWindows, 0)
 

        

        
~
    // プロセス名を表示
    End Sub
+
    Console.WriteLine("({0})", p.ProcessName);
+
  }
+
}
+
}}
+
#tabpage(VB)
+
#code(vb){{
+
Imports System
+
Imports System.Diagnostics
+
Imports System.Runtime.InteropServices
+
Imports System.Text
 

        

        
+
Class Sample
+
  <DllImport("user32")> _
+
  Private Shared Function EnumWindows(ByVal lpEnumFunc As WNDENUMPROC, ByVal lParam As IntPtr) As Boolean
+
  End Function
+

          
+
  ' EnumWindowsから呼び出されるコールバック関数WNDENUMPROCのデリゲート
+
  Private Delegate Function WNDENUMPROC(ByVal hWnd As IntPtr, ByVal lParam As IntPtr) As Boolean
+

          
+
  <DllImport("user32")> _
+
  Private Shared Function IsWindowVisible(ByVal hWnd As IntPtr) As Boolean
+
  End Function
+

          
+
  <DllImport("user32", CharSet := CharSet.Auto)> _
+
  Private Shared Function GetWindowText(ByVal hWnd As IntPtr, ByVal lpString As StringBuilder, ByVal nMaxCount As Integer) As Integer
+
  End Function
+

          
+
  <DllImport("user32")> _
+
  Private Shared Function GetWindowThreadProcessId(ByVal hWnd As IntPtr, <Out> ByRef lpdwProcessId As Integer) As Integer
+
  End Function
+

          
+
  Public Shared Sub Main()
+
    ' ウィンドウの列挙を開始
+
    EnumWindows(AddressOf EnumerateWindow, IntPtr.Zero)
+
  End Sub
+

          
+
  ' ウィンドウを列挙するためのコールバックメソッド
+
  Private Shared Function EnumerateWindow(ByVal hWnd As IntPtr, ByVal lParam As IntPtr) As Boolean
+
    ' ウィンドウが可視かどうか調べる
+
    If IsWindowVisible(hWnd) Then
+
      ' 可視の場合
+
      PrintCaptionAndProcess(hWnd)
+
    End If
+

          
+
    ' ウィンドウの列挙を継続するにはTrueを返す必要がある
+
    Return True
+
  End Function
+

          
+
  ' ウィンドウのキャプションとプロセス名を表示する
+
  Private Shared Sub PrintCaptionAndProcess(ByVal hWnd As IntPtr)
+
    ' ウィンドウのキャプションを取得・表示
+
    Dim caption As New StringBuilder(&h1000)
+

          
+
    GetWindowText(hWnd, caption, caption.Capacity)
+

          
+
    Console.Write("'{0}' ", caption)
+

          
+
    ' ウィンドウハンドルからプロセスIDを取得
+
    Dim processId As Integer
+

          
+
    GetWindowThreadProcessId(hWnd, processId)
+

          
+
    ' プロセスIDからProcessクラスのインスタンスを取得
+
    Dim p As Process = Process.GetProcessById(processId)
+

          
+
    ' プロセス名を表示
+
    Console.WriteLine("({0})", p.ProcessName)
+
  End Sub
 
End Class
End Class
 
}}
}}
 
#tabpage-end
#tabpage-end
 

        

        
 
#prompt(出力例){{
#prompt(出力例){{
~
'Windows タスク マネージャ' (taskmgr)
Light Executer
~
'スタート' (explorer)
E:\Visual C# .NET Program\Samples\EnumerateWindows\bin\Debug\EnumerateWindows.exe
~
'' (explorer)
EnumerateWindows - Microsoft Visual C# .NET [デザイン] - Class1.cs
~
'C:\Windows\system32\cmd.exe - test.exe  ' (cmd)
EnumerateWindows - Microsoft Visual C# .NET [デザイン] - Class1.cs
~
'test.vb - メモ帳' (notepad)
Windows Media Player
~
'test.cs - メモ帳' (notepad)
VBCS翻訳機 version 1.2
~
'D:\' (explorer)
CodeToHTML version 1.5
~
'Program Manager' (explorer)
Program Manager
-
Press any key to continue
 
}}
}}
 

        

        
~
なお、可視でないウィンドウも列挙するには、IsWindowVisible()の部分を削除すればよい。
可視でないウィンドウを列挙するには、IsWindowVisible()の部分を削除すればよい。