Export (0) Print
Expand All

Binder Class

Selects a member from a list of candidates, and performs type conversion from actual argument type to formal argument type.

Namespace: System.Reflection
Assembly: mscorlib (in mscorlib.dll)

'Declaration
<SerializableAttribute> _
<ClassInterfaceAttribute(ClassInterfaceType.AutoDual)> _
<ComVisibleAttribute(True)> _
Public MustInherit Class Binder
'Usage
Dim instance As Binder

/** @attribute SerializableAttribute() */ 
/** @attribute ClassInterfaceAttribute(ClassInterfaceType.AutoDual) */ 
/** @attribute ComVisibleAttribute(true) */ 
public abstract class Binder
SerializableAttribute 
ClassInterfaceAttribute(ClassInterfaceType.AutoDual) 
ComVisibleAttribute(true) 
public abstract class Binder
Not applicable.

Implementations of the Binder class are used by methods such as Type.InvokeMember, which selects from a set of possible members to execute, based on a set of parameter types and argument values; Type.GetMethod, which selects a method based on parameter types; and so on.

A default implementation of the Binder class is provided by the Type.DefaultBinder property.

Notes to Inheritors: When you inherit from Binder, you must override the following members: BindToMethod, BindToField, ReorderArgumentArray, SelectMethod, SelectProperty, and ChangeType.

The following example implements and demonstrates all members of the Binder class. The private method CanConvertFrom finds compatible types for a given type.

Imports System
Imports System.Reflection
Imports System.Globalization
Imports Microsoft.VisualBasic

Public Class MyBinder
    Inherits Binder
    Public Sub New()
        MyBase.new()
    End Sub 'New
    Private Class BinderState
        Public args() As Object
    End Class 'BinderState

    Public Overrides Function BindToField(ByVal bindingAttr As BindingFlags, ByVal match() As FieldInfo, ByVal value As Object, ByVal culture As CultureInfo) As FieldInfo
        If match Is Nothing Then
            Throw New ArgumentNullException("match")
        End If
        ' Get a field for which the value parameter can be converted to the specified field type.
        Dim i As Integer
        For i = 0 To match.Length - 1
            If Not (ChangeType(value, match(i).FieldType, culture) Is Nothing) Then
                Return match(i)
            End If
        Next i
        Return Nothing
    End Function 'BindToField

    Public Overrides Function BindToMethod(ByVal bindingAttr As BindingFlags, ByVal match() As MethodBase, ByRef args() As Object, ByVal modifiers() As ParameterModifier, ByVal culture As CultureInfo, ByVal names() As String, ByRef state As Object) As MethodBase
        ' Store the arguments to the method in a state object.
        Dim myBinderState As New BinderState()
        Dim arguments() As Object = New [Object](args.Length) {}
        args.CopyTo(arguments, 0)
        myBinderState.args = arguments
        state = myBinderState

        If match Is Nothing Then
            Throw New ArgumentNullException()
        End If
        ' Find a method that has the same parameters as those of args.
        Dim i As Integer
        For i = 0 To match.Length - 1
            ' Count the number of parameters that match.
            Dim count As Integer = 0
            Dim parameters As ParameterInfo() = match(i).GetParameters()
            ' Go on to the next method if the number of parameters do not match.
            If args.Length <> parameters.Length Then
                GoTo ContinueFori
            End If
            ' Match each of the parameters that the user expects the method to have.
            Dim j As Integer
            For j = 0 To args.Length - 1
                ' If names is not null, then reorder args.
                If Not (names Is Nothing) Then
                    If names.Length <> args.Length Then
                        Throw New ArgumentException("names and args must have the same number of elements.")
                    End If
                    Dim k As Integer
                    For k = 0 To names.Length - 1
                        If String.Compare(parameters(j).Name, names(k).ToString()) = 0 Then
                            args(j) = myBinderState.args(k)
                        End If
                    Next k
                End If ' Determine whether the types specified by the user can be converted to parameter type.
                If Not (ChangeType(args(j), parameters(j).ParameterType, culture) Is Nothing) Then
                    count += 1
                Else
                    Exit For
                End If
            Next j
            ' Determine whether the method has been found.
            If count = args.Length Then
                Return match(i)
            End If
ContinueFori:
        Next i
        Return Nothing
    End Function 'BindToMethod

    Public Overrides Function ChangeType(ByVal value As Object, ByVal myChangeType As Type, ByVal culture As CultureInfo) As Object
        ' Determine whether the value parameter can be converted to a value of type myType.
        If CanConvertFrom(value.GetType(), myChangeType) Then
            ' Return the converted object.
            Return Convert.ChangeType(value, myChangeType)
            ' Return null.
        Else
            Return Nothing
        End If
    End Function 'ChangeType

    Public Overrides Sub ReorderArgumentArray(ByRef args() As Object, ByVal state As Object)
        'Redimension the array to hold the state values.
        ReDim args(CType(state, BinderState).args.Length)
        ' Return the args that had been reordered by BindToMethod.
        CType(state, BinderState).args.CopyTo(args, 0)
    End Sub 'ReorderArgumentArray

    Public Overrides Function SelectMethod(ByVal bindingAttr As BindingFlags, ByVal match() As MethodBase, ByVal types() As Type, ByVal modifiers() As ParameterModifier) As MethodBase
        If match Is Nothing Then
            Throw New ArgumentNullException("match")
        End If
        Dim i As Integer
        For i = 0 To match.Length - 1
            ' Count the number of parameters that match.
            Dim count As Integer = 0
            Dim parameters As ParameterInfo() = match(i).GetParameters()
            ' Go on to the next method if the number of parameters do not match.
            If types.Length <> parameters.Length Then
                GoTo ContinueFori
            End If
            ' Match each of the parameters that the user expects the method to have.
            Dim j As Integer
            For j = 0 To types.Length - 1
                ' Determine whether the types specified by the user can be converted to parameter type.
                If CanConvertFrom(types(j), parameters(j).ParameterType) Then
                    count += 1
                Else
                    Exit For
                End If
            Next j ' Determine whether the method has been found.
            If count = types.Length Then
                Return match(i)
            End If
ContinueFori:
        Next i
        Return Nothing
    End Function 'SelectMethod
    Public Overrides Function SelectProperty(ByVal bindingAttr As BindingFlags, ByVal match() As PropertyInfo, ByVal returnType As Type, ByVal indexes() As Type, ByVal modifiers() As ParameterModifier) As PropertyInfo
        If match Is Nothing Then
            Throw New ArgumentNullException("match")
        End If
        Dim i As Integer
        For i = 0 To match.Length - 1
            ' Count the number of indexes that match.
            Dim count As Integer = 0
            Dim parameters As ParameterInfo() = match(i).GetIndexParameters()

            ' Go on to the next property if the number of indexes do not match.
            If indexes.Length <> parameters.Length Then
                GoTo ContinueFori
            End If
            ' Match each of the indexes that the user expects the property to have.
            Dim j As Integer
            For j = 0 To indexes.Length - 1
                ' Determine whether the types specified by the user can be converted to index type.
                If CanConvertFrom(indexes(j), parameters(j).ParameterType) Then
                    count += 1
                Else
                    Exit For
                End If
            Next j ' Determine whether the property has been found.
            If count = indexes.Length Then
                ' Determine whether the return type can be converted to the properties type.
                If CanConvertFrom(returnType, match(i).PropertyType) Then
                    Return match(i)
                Else
                    GoTo ContinueFori
                End If
            End If
ContinueFori:
        Next i
        Return Nothing
    End Function 'SelectProperty

    ' Determine whether type1 can be converted to type2. Check only for primitive types.
    Private Function CanConvertFrom(ByVal type1 As Type, ByVal type2 As Type) As Boolean
        If type1.IsPrimitive And type2.IsPrimitive Then
            Dim typeCode1 As TypeCode = Type.GetTypeCode(type1)
            Dim typeCode2 As TypeCode = Type.GetTypeCode(type2)
            ' If both type1 and type2 have same type, return true.
            If typeCode1 = typeCode2 Then
                Return True
            End If ' Possible conversions from Char follow.
            If typeCode1 = TypeCode.Char Then
                Select Case typeCode2
                    Case TypeCode.UInt16
                        Return True
                    Case TypeCode.UInt32
                        Return True
                    Case TypeCode.Int32
                        Return True
                    Case TypeCode.UInt64
                        Return True
                    Case TypeCode.Int64
                        Return True
                    Case TypeCode.Single
                        Return True
                    Case TypeCode.Double
                        Return True
                    Case Else
                        Return False
                End Select
            End If ' Possible conversions from Byte follow.
            If typeCode1 = TypeCode.Byte Then
                Select Case typeCode2
                    Case TypeCode.Char
                        Return True
                    Case TypeCode.UInt16
                        Return True
                    Case TypeCode.Int16
                        Return True
                    Case TypeCode.UInt32
                        Return True
                    Case TypeCode.Int32
                        Return True
                    Case TypeCode.UInt64
                        Return True
                    Case TypeCode.Int64
                        Return True
                    Case TypeCode.Single
                        Return True
                    Case TypeCode.Double
                        Return True
                    Case Else
                        Return False
                End Select
            End If ' Possible conversions from SByte follow.
            If typeCode1 = TypeCode.SByte Then
                Select Case typeCode2
                    Case TypeCode.Int16
                        Return True
                    Case TypeCode.Int32
                        Return True
                    Case TypeCode.Int64
                        Return True
                    Case TypeCode.Single
                        Return True
                    Case TypeCode.Double
                        Return True
                    Case Else
                        Return False
                End Select
            End If ' Possible conversions from UInt16 follow.
            If typeCode1 = TypeCode.UInt16 Then
                Select Case typeCode2
                    Case TypeCode.UInt32
                        Return True
                    Case TypeCode.Int32
                        Return True
                    Case TypeCode.UInt64
                        Return True
                    Case TypeCode.Int64
                        Return True
                    Case TypeCode.Single
                        Return True
                    Case TypeCode.Double
                        Return True
                    Case Else
                        Return False
                End Select
            End If ' Possible conversions from Int16 follow.
            If typeCode1 = TypeCode.Int16 Then
                Select Case typeCode2
                    Case TypeCode.Int32
                        Return True
                    Case TypeCode.Int64
                        Return True
                    Case TypeCode.Single
                        Return True
                    Case TypeCode.Double
                        Return True
                    Case Else
                        Return False
                End Select
            End If ' Possible conversions from UInt32 follow.
            If typeCode1 = TypeCode.UInt32 Then
                Select Case typeCode2
                    Case TypeCode.UInt64
                        Return True
                    Case TypeCode.Int64
                        Return True
                    Case TypeCode.Single
                        Return True
                    Case TypeCode.Double
                        Return True
                    Case Else
                        Return False
                End Select
            End If ' Possible conversions from Int32 follow.
            If typeCode1 = TypeCode.Int32 Then
                Select Case typeCode2
                    Case TypeCode.Int64
                        Return True
                    Case TypeCode.Single
                        Return True
                    Case TypeCode.Double
                        Return True
                    Case Else
                        Return False
                End Select
            End If ' Possible conversions from UInt64 follow.
            If typeCode1 = TypeCode.UInt64 Then
                Select Case typeCode2
                    Case TypeCode.Single
                        Return True
                    Case TypeCode.Double
                        Return True
                    Case Else
                        Return False
                End Select
            End If ' Possible conversions from Int64 follow.
            If typeCode1 = TypeCode.Int64 Then
                Select Case typeCode2
                    Case TypeCode.Single
                        Return True
                    Case TypeCode.Double
                        Return True
                    Case Else
                        Return False
                End Select
            End If ' Possible conversions from Single follow.
            If typeCode1 = TypeCode.Single Then
                Select Case typeCode2
                    Case TypeCode.Double
                        Return True
                    Case Else
                        Return False
                End Select
            End If
        End If
        Return False
    End Function 'CanConvertFrom
End Class 'MyBinder


Public Class MyClass1
    Public myFieldB As Short
    Public myFieldA As Integer

    Public Overloads Sub MyMethod(ByVal i As Long, ByVal k As Char)
        Console.WriteLine(ControlChars.NewLine & "This is MyMethod(long i, char k).")
    End Sub 'MyMethod

    Public Overloads Sub MyMethod(ByVal i As Long, ByVal j As Long)
        Console.WriteLine(ControlChars.NewLine & "This is MyMethod(long i, long j).")
    End Sub 'MyMethod
End Class 'MyClass1


Public Class Binder_Example
    Public Shared Sub Main()
        ' Get the type of MyClass1.
        Dim myType As Type = GetType(MyClass1)
        ' Get the instance of MyClass1.
        Dim myInstance As New MyClass1()
        Console.WriteLine(ControlChars.Cr & "Displaying the results of using the MyBinder binder.")
        Console.WriteLine()
        ' Get the method information for MyMethod.
        Dim myMethod As MethodInfo = myType.GetMethod("MyMethod", BindingFlags.Public Or BindingFlags.Instance, New MyBinder(), New Type() {GetType(Short), GetType(Short)}, Nothing)
        Console.WriteLine(MyMethod)
        ' Invoke MyMethod.
        myMethod.Invoke(myInstance, BindingFlags.InvokeMethod, New MyBinder(), New [Object]() {CInt(32), CInt(32)}, CultureInfo.CurrentCulture)
    End Sub 'Main
End Class 'Binder_Example

import System.*;
import System.Reflection.*;
import System.Globalization.*;

public class MyBinder extends Binder
{
    public MyBinder()
    {
    } //MyBinder

    private class BinderState
    {
        public Object args[];
    } //BinderState

    public FieldInfo BindToField(BindingFlags bindingAttr, FieldInfo match[], 
        Object value, CultureInfo culture)
    {
        if (match == null) {
            throw new ArgumentNullException("match");
        }

        // Get a field for which the value parameter can be converted 
        // to the specified field type.
        for (int i = 0; i < match.length; i++) {
            if (ChangeType(value, 
                ((FieldInfo)match.get_Item(i)).get_FieldType(), culture) 
                != null) {
                return (FieldInfo)match.get_Item(i);
            }
        }

        return null;
    } //BindToField

    public MethodBase BindToMethod(BindingFlags bindingAttr, MethodBase match[],
        /**@ref
         */
        Object args[], ParameterModifier modifiers[], CultureInfo culture, 
        String names[],
        /**@ref
         */ Object state)
    {
        // Store the arguments to the method in a state object.
        BinderState myBinderState = new BinderState();
        Object arguments[] = new Object[args.length];

        args.CopyTo(arguments, 0);
        myBinderState.args = arguments;
        state = myBinderState;
        if (match == null) {
            throw new ArgumentNullException();
        }

        // Find a method that has the same parameters as those of the 
        // args parameter.
        for (int i = 0; i < match.length; i++) {
            // Count the number of parameters that match.
            int count = 0;
            ParameterInfo parameters[] = ((MethodBase)match.get_Item(i)).
                GetParameters();

            // Go on to the next method if the number of 
            // parameters do not match.
            if (args.length != parameters.length) {
                continue;
            }

            // Match each of the parameters that the user expects 
            // the method to have.
            for (int j = 0; j < args.length; j++) {
                // If the names parameter is not null, then reorder args.
                if (names != null) {
                    if (names.length != args.length) {
                        throw new ArgumentException("names and args must have "
                            + "the same number of elements.");
                    }

                    for (int k = 0; k < names.length; k++) {
                        if (String.Compare(((ParameterInfo)parameters.
                            get_Item(j)).get_Name(), 
                            names.get_Item(k).ToString()) == 0) {

                            args[j] = myBinderState.args.get_Item(k);
                        }
                    }
                }

                // Determine whether the types specified by the user can be 
                // converted to the parameter type.
                if (ChangeType(args[j], ((ParameterInfo)parameters.get_Item(j)).
                    get_ParameterType(), culture) != null) {
                    count += 1;
                }
                else {
                    break;
                }
            }  
            // Determine whether the method has been found.
            if (count == args.length) {
                return (MethodBase)match.get_Item(i);
            }
        }
        return null;
    } //BindToMethod

    public Object ChangeType(Object value, Type myChangeType, 
        CultureInfo culture)
    {
        // Determine whether the value parameter can be converted to a 
        // value of type myType.
        if (CanConvertFrom(value.GetType(), myChangeType)) {
            // Return the converted object.
            return Convert.ChangeType(value, myChangeType);
        }
        else {
            // Return null.
            return null;
        }
    } //ChangeType

    public void ReorderArgumentArray(
        /**@ref
         */Object args[], Object state)
    {
        // Return the args that had been reordered by BindToMethod.
        ((BinderState)state).args.CopyTo(args, 0);
    } //ReorderArgumentArray


    public MethodBase SelectMethod(BindingFlags bindingAttr, MethodBase match[], 
        Type types[], ParameterModifier modifiers[])
    {
        if (match == null) {
            throw new ArgumentNullException("match");
        }

        for (int i = 0; i < match.length; i++) {
            // Count the number of parameters that match.
            int count = 0;
            ParameterInfo parameters[] = ((MethodBase)match.get_Item(i)).
                GetParameters();

            // Go on to the next method if the number of parameters 
            // do not match.
            if (types.length != parameters.length) {
                continue;
            }

            // Match each of the parameters that the user expects 
            // the method  to have.
            for (int j = 0; j < types.length; j++) {
                // Determine whether the types specified by the user can be 
                // converted to parameter type.
                if (CanConvertFrom((Type)types.get_Item(j), 
                    ((ParameterInfo)parameters.get_Item(j)).
                    get_ParameterType())) {

                    count += 1;
                }
                else {
                    break;
                } 
            }
            // Determine whether the method has been found.
            if (count == types.length) {
                return (MethodBase)match.get_Item(i);
            }
        }

        return null;
    } //SelectMethod

    public PropertyInfo SelectProperty(BindingFlags bindingAttr, 
        PropertyInfo match[], Type returnType, Type indexes[], 
        ParameterModifier modifiers[])
    {
        if (match == null) {
            throw new ArgumentNullException("match");
        }

        for (int i = 0; i < match.length; i++) {
            // Count the number of indexes that match.
            int count = 0;
            ParameterInfo parameters[] = ((PropertyInfo)match.get_Item(i)).
                GetIndexParameters();

            // Go on to the next property if the number of indexes do not match.
            if (indexes.length != parameters.length) {
                continue;
            }

            // Match each of the indexes that the user expects 
            // the property to have.
            for (int j = 0; j < indexes.length; j++) {
                // Determine whether the types specified by the user 
                // can be converted to index type.
                if (CanConvertFrom((Type)indexes.get_Item(j), 
                    ((ParameterInfo)parameters.get_Item(j)).
                    get_ParameterType())) {

                    count += 1;
                }
                else {
                    break;
                } 
            }
            // Determine whether the property has been found.
            if (count == indexes.length) {
                // Determine whether the return type can be converted 
                // to the properties type.
                if (CanConvertFrom(returnType, ((PropertyInfo)match.get_Item(i)).get_PropertyType())) {
                    return (PropertyInfo)match.get_Item(i);
                }
                else {
                    continue;
                }
            }
        }
        return null;
    } //SelectProperty

    // Determines whether type1 can be converted to type2. 
    // Check only for primitive types.
    private boolean CanConvertFrom(Type type1, Type type2)
    {
        if (type1.get_IsPrimitive() && type2.get_IsPrimitive()) {
            TypeCode typeCode1 = Type.GetTypeCode(type1);
            TypeCode typeCode2 = Type.GetTypeCode(type2);

            // If both type1 and type2 have the same type, return true.
            if (typeCode1.Equals(typeCode2)) {
                return true;
            }

            // Possible conversions from Char follow.
            if (typeCode1.Equals(TypeCode.Char)) {
                switch (typeCode2) {
                    case TypeCode.UInt16 :
                        return true;
                    case TypeCode.UInt32 : 
                        return true;
                    case TypeCode.Int32  : 
                        return true;
                    case TypeCode.UInt64 : 
                        return true;
                    case TypeCode.Int64  : 
                        return true;
                    case TypeCode.Single : 
                        return true;
                    case TypeCode.Double : 
                        return true;
                    default : 
                        return false;
                }
            }

            // Possible conversions from Byte follow.
            if (typeCode1.Equals(TypeCode.Byte)) {
                switch (typeCode2) {
                    case TypeCode.Char   : 
                        return true;
                    case TypeCode.UInt16 : 
                        return true;
                    case TypeCode.Int16  : 
                        return true;
                    case TypeCode.UInt32 : 
                        return true;
                    case TypeCode.Int32  : 
                        return true;
                    case TypeCode.UInt64 :
                        return true;
                    case TypeCode.Int64  :
                        return true;
                    case TypeCode.Single : 
                        return true;
                    case TypeCode.Double : 
                        return true;
                    default : 
                        return false;
                }
            }

            // Possible conversions from SByte follow.
            if (typeCode1.Equals(TypeCode.SByte)) {
                switch (typeCode2) {
                    case TypeCode.Int16  : 
                        return true;
                    case TypeCode.Int32  : 
                        return true;
                    case TypeCode.Int64  : 
                        return true;
                    case TypeCode.Single : 
                        return true;
                    case TypeCode.Double : 
                        return true;
                    default : 
                        return false;
                }
            }

            // Possible conversions from UInt16 follow.
            if (typeCode1.Equals(TypeCode.UInt16)) {
                switch (typeCode2) {
                    case TypeCode.UInt32 : 
                        return true;
                    case TypeCode.Int32  : 
                        return true;
                    case TypeCode.UInt64 : 
                        return true;
                    case TypeCode.Int64  : 
                        return true;
                    case TypeCode.Single : 
                        return true;
                    case TypeCode.Double : 
                        return true;
                    default : 
                        return false;
                }
            }

            // Possible conversions from Int16 follow.
            if (typeCode1.Equals(TypeCode.Int16)) {
                switch (typeCode2) {
                    case TypeCode.Int32  : 
                        return true;
                    case TypeCode.Int64  : 
                        return true;
                    case TypeCode.Single : 
                        return true;
                    case TypeCode.Double : 
                        return true;
                    default : 
                        return false;
                }
            }

            // Possible conversions from UInt32 follow.
            if (typeCode1.Equals(TypeCode.UInt32)) {
                switch (typeCode2) {
                    case TypeCode.UInt64 : 
                        return true;
                    case TypeCode.Int64  : 
                        return true;
                    case TypeCode.Single : 
                        return true;
                    case TypeCode.Double : 
                        return true;
                    default : 
                        return false;
                }
            }

            // Possible conversions from Int32 follow.
            if (typeCode1.Equals(TypeCode.Int32)) {
                switch (typeCode2) {
                    case TypeCode.Int64  : 
                        return true;
                    case TypeCode.Single : 
                        return true;
                    case TypeCode.Double : 
                        return true;
                    default : 
                        return false;
                }
            }

            // Possible conversions from UInt64 follow.
            if (typeCode1.Equals(TypeCode.UInt64)) {
                switch (typeCode2) {
                    case TypeCode.Single : 
                        return true;
                    case TypeCode.Double : 
                        return true;
                    default : 
                        return false;
                }
            }

            // Possible conversions from Int64 follow.
            if (typeCode1.Equals(TypeCode.Int64)) {
                switch (typeCode2) {
                    case TypeCode.Single : 
                        return true;
                    case TypeCode.Double : 
                        return true;
                    default : 
                        return false;
                }
            }

            // Possible conversions from Single follow.
            if (typeCode1.Equals(TypeCode.Single)) {
                switch (typeCode2) {
                    case TypeCode.Double : 
                        return true;
                    default : 
                        return false;
                }
            }
        }
        return false;
    } //CanConvertFrom
} //MyBinder

public class MyClass1
{
    public short myFieldB;
    public int myFieldA;

    public void MyMethod(long i, char k)
    {
        Console.WriteLine("\nThis is MyMethod(long i, char k)");
    } //MyMethod

    public void MyMethod(long i, long j)
    {
        Console.WriteLine("\nThis is MyMethod(long i, long j)");
    } //MyMethod
} //MyClass1

public class BinderExample
{
    public static void main(String[] args)
    {
        // Get the type of MyClass1.
        Type myType = MyClass1.class.ToType();

        // Get the instance of MyClass1.
        MyClass1 myInstance = new MyClass1();

        Console.WriteLine("\nDisplaying the results of using the "
            + "MyBinder binder.\n");

        // Get the method information for MyMethod.
        MethodInfo myMethod = myType.GetMethod("MyMethod", 
            BindingFlags.Public | BindingFlags.Instance, new MyBinder(), 
            new Type[] { short.class.ToType(), short.class.ToType() }, null);
        Console.WriteLine(myMethod);

        // Invoke MyMethod.
        myMethod.Invoke(myInstance, BindingFlags.InvokeMethod, new MyBinder(),
            new Object[] { (Int32)32, (Int32)32 }, 
            CultureInfo.get_CurrentCulture());
    } //main
} //BinderExample

System.Object
  System.Reflection.Binder

Any public static (Shared in Visual Basic) members of this type are thread safe. Any instance members are not guaranteed to be thread safe.

Windows 98, Windows Server 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile for Pocket PC, Windows Mobile for Smartphone, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

The Microsoft .NET Framework 3.0 is supported on Windows Vista, Microsoft Windows XP SP2, and Windows Server 2003 SP1.

.NET Framework

Supported in: 3.0, 2.0, 1.1, 1.0

.NET Compact Framework

Supported in: 2.0, 1.0

XNA Framework

Supported in: 1.0

Community Additions

ADD
Show:
© 2014 Microsoft