Cette documentation est archivée et n’est pas conservée.

SecurityPermission, classe

Décrit un ensemble d'autorisations de sécurité appliquées au code. Cette classe ne peut pas être héritée.

Espace de noms : System.Security.Permissions
Assembly : mscorlib (dans mscorlib.dll)

[SerializableAttribute] 
[ComVisibleAttribute(true)] 
public sealed class SecurityPermission : CodeAccessPermission, IUnrestrictedPermission
/** @attribute SerializableAttribute() */ 
/** @attribute ComVisibleAttribute(true) */ 
public final class SecurityPermission extends CodeAccessPermission implements IUnrestrictedPermission
SerializableAttribute 
ComVisibleAttribute(true) 
public final class SecurityPermission extends CodeAccessPermission implements IUnrestrictedPermission

Cette autorisation utilise l'énumération SecurityPermissionFlag. Les valeurs de cette énumération se trouvent dans la documentation correspondante.

L'exemple de code suivant illustre le comportement des méthodes de la classe SecurityPermission. Cet exemple est destiné à montrer les résultats des méthodes, et non à illustrer la manière dont elles sont généralement utilisées. Pour obtenir un exemple d'utilisation de la classe SecurityPermission afin de demander l'autorisation pour une valeur d'énumération SecurityPermissionFlag spécifique, consultez le constructeur SecurityPermission(SecurityPermissionFlag).

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

[assembly:CLSCompliant(true)]
public class SecurityPermissionDemo
{
    // IsSubsetOf determines whether the current permission is a subset of the specified permission.
    private bool IsSubsetOfDemo()
    {
        bool returnValue = true;
        SecurityPermissionFlag security1,security2;
        SecurityPermission securityPerm1,securityPerm2;
        SecurityGenerator SecurityGen1 = new SecurityGenerator();
        SecurityGenerator SecurityGen2 = new SecurityGenerator();
        SecurityGen1.ResetIndex();
        while(SecurityGen1.GetSecurityFlag( out security1 ))
        {
            securityPerm1 = new SecurityPermission(security1);
            SecurityGen2.ResetIndex();
            Console.WriteLine("********************************************************\n");

            while(SecurityGen2.GetSecurityFlag( out security2 ))
            {
                securityPerm2 = new SecurityPermission(security2);
                try
                {
                    if (securityPerm1.IsSubsetOf(securityPerm2))
                    {
                        Console.WriteLine(securityPerm1.Flags + " is a subset of " +
                            securityPerm2.Flags);
                    }
                    else
                    {
                        Console.WriteLine(securityPerm1.Flags + " is not a subset of " +
                            securityPerm2.Flags);
                    }
                }
                catch(Exception e)
                {
                    Console.WriteLine("An exception was thrown for subset :" + securityPerm1 + "\n" +
                        securityPerm2 +"\n" + e);
                    returnValue=false;
                }
            }
        }
        return returnValue;
    }
    // Union creates a new permission that is the union of the current permission and the specified permission.
    private bool UnionDemo()
    {
        bool returnValue = true;
        SecurityPermissionFlag security1,security2;
        SecurityPermission securityPerm1,securityPerm2;
        IPermission SecurityPerm3;
        SecurityGenerator SecurityGen1 = new SecurityGenerator();
        SecurityGenerator SecurityGen2 = new SecurityGenerator();
        SecurityGen1.ResetIndex();
        while(SecurityGen1.GetSecurityFlag(  out security1 ))
        {
            securityPerm1 = new SecurityPermission(security1);
            Console.WriteLine("**********************************************************\n");
            SecurityGen2.ResetIndex();

            while(SecurityGen2.GetSecurityFlag( out security2 ))
            {
                securityPerm2 = new SecurityPermission(security2);
                SecurityPerm3 = (SecurityPermission)securityPerm1.Union(securityPerm2);
                SecurityPerm3 = securityPerm1.Union(securityPerm2);

                if(SecurityPerm3 == null)
                {
                    Console.WriteLine("The union of " + security1 + " and " + security2 + " is null." );
                }
                else
                {
                    Console.WriteLine("The union of " + securityPerm1.Flags + " and " +
                        securityPerm2.Flags + " = " +
                        ((SecurityPermission)SecurityPerm3).Flags.ToString());
                }

            }
        }

        return returnValue;

    }
    // Intersect creates and returns a new permission that is the intersection of the current
    // permission and the permission specified.
    private bool IntersectDemo()
    {
        bool returnValue = true;
        SecurityPermissionFlag security1,security2;
        SecurityPermission securityPerm1,securityPerm2,SecurityPerm3;
        SecurityGenerator SecurityGen1 = new SecurityGenerator();
        SecurityGenerator SecurityGen2 = new SecurityGenerator();
        SecurityGen1.ResetIndex();
        while(SecurityGen1.GetSecurityFlag( out security1 ))
        {
            securityPerm1 = new SecurityPermission(security1);
            Console.WriteLine("**********************************************************\n");
            SecurityGen2.ResetIndex();

            while(SecurityGen2.GetSecurityFlag( out security2 ))
            {
                securityPerm2 = new SecurityPermission(security2);

                SecurityPerm3 = (SecurityPermission)securityPerm1.Intersect(securityPerm2);
                if (SecurityPerm3 != null)
                {
                    Console.WriteLine("The intersection of " + security1 + " and " + security2 + " = " +
                        ((SecurityPermission)SecurityPerm3).Flags.ToString());
                }
                else
                {
                    Console.WriteLine("The intersection of " + security1 + " and " + security2 + " is null." );
                }
            }
        }

        return returnValue;
    }
    //Copy creates and returns an identical copy of the current permission.
    private bool CopyDemo()
    {

        bool returnValue = true;

        SecurityPermissionFlag security1;
        SecurityPermission securityPerm1,securityPerm2;

        SecurityGenerator SecurityGen1 = new SecurityGenerator();
        SecurityGenerator SecurityGen2 = new SecurityGenerator();

        SecurityGen1.ResetIndex();
        while(SecurityGen1.GetSecurityFlag( out security1 ))
        {
            securityPerm1 = new SecurityPermission(security1);
            SecurityGen2.ResetIndex();
            Console.WriteLine("********************************************************\n");
            try
            {
                securityPerm2 = (SecurityPermission)securityPerm1.Copy();
                Console.WriteLine("Result of copy = " + securityPerm2.ToString());

            }
            catch(Exception e)
            {
                Console.WriteLine("Copy failed :" + securityPerm1.ToString() + e);
                continue;
            }
        }
        return returnValue;
    }
    // ToXml creates an XML encoding of the permission and its current state;
    // FromXml reconstructs a permission with the specified state from the XML encoding.
    private bool ToFromXmlDemo()
    {

        bool returnValue = true;

        SecurityPermissionFlag security1;
        SecurityPermission securityPerm1,securityPerm2;
        SecurityGenerator SecurityGen1 = new SecurityGenerator();
        SecurityGenerator SecurityGen2 = new SecurityGenerator();
        SecurityGen1.ResetIndex();
        while(SecurityGen1.GetSecurityFlag( out security1 ))
        {
            securityPerm1 = new SecurityPermission(security1);
            Console.WriteLine("********************************************************\n");
            SecurityGen2.ResetIndex();
            try
            {
                securityPerm2= new SecurityPermission(PermissionState.None);
                securityPerm2.FromXml(securityPerm1.ToXml());
                Console.WriteLine("Result of ToFromXml = " +
                    securityPerm2.ToString());

            }
            catch(Exception e)
            {
                Console.WriteLine("ToFromXml failed :" + securityPerm1.ToString() + e);
                continue;
            }
        }

        return returnValue;

    }
    // Invoke all demos.
    public bool runDemo()
    {
        bool returnCode = true;
        bool tempReturnCode;

        // Call the IsSubsetOf demo.
        tempReturnCode= IsSubsetOfDemo();
        if(tempReturnCode)Console.Out.WriteLine("IsSubsetOf demo completed successfully.");
        else Console.Out.WriteLine("IsSubsetOf demo failed.");
        returnCode=tempReturnCode && returnCode;

        // Call the Union demo.
        tempReturnCode= UnionDemo();
        if(tempReturnCode)Console.Out.WriteLine("Union demo completed successfully.");
        else Console.Out.WriteLine("Union demo failed.");
        returnCode=tempReturnCode && returnCode;

        // Call the Intersect demo.
        tempReturnCode= IntersectDemo();
        if(tempReturnCode)Console.Out.WriteLine("Intersect demo completed successfully.");
        else Console.Out.WriteLine("Intersect demo failed.");
        returnCode=tempReturnCode && returnCode;


        // Call the Copy demo.
        tempReturnCode= CopyDemo();
        if(tempReturnCode)Console.Out.WriteLine("Copy demo completed successfully.");
        else Console.Out.WriteLine("Copy demo failed.");
        returnCode=tempReturnCode && returnCode;

        // Call the ToFromXml demo.
        tempReturnCode= ToFromXmlDemo();
        if(tempReturnCode)Console.Out.WriteLine("ToFromXml demo completed successfully.");
        else Console.Out.WriteLine("ToFromXml demo failed.");
        returnCode=tempReturnCode && returnCode;

        return ( returnCode );
    }
    // Test harness.
    public static void Main(String[] args)
    {
        try
        {
            SecurityPermissionDemo democase = new SecurityPermissionDemo();
            bool returnCode = democase.runDemo();
            if (returnCode)
            {
                Console.Out.WriteLine("SecurityPermission demo completed successfully.");
                Console.Out.WriteLine("Press the Enter key to exit.");
                string consoleInput = Console.ReadLine();
                System.Environment.ExitCode = 100;
            }
            else
            {
                Console.Out.WriteLine("SecurityPermission demo failed.");
                Console.Out.WriteLine("Press the Enter key to exit.");
                string consoleInput = Console.ReadLine();
                System.Environment.ExitCode = 101;
            }
        }
        catch(Exception e)
        {
            Console.Out.WriteLine("SecurityPermission demo failed.");
            Console.WriteLine(e.ToString());
            Console.Out.WriteLine("Press the Enter key to exit.");
            string consoleInput = Console.ReadLine();
            System.Environment.ExitCode = 101;
        }
    }
}


// This class generates SecurityPermission objects.

internal class SecurityGenerator
{


    private SecurityPermissionFlag[] mySecurity =
{
    SecurityPermissionFlag.AllFlags,
    SecurityPermissionFlag.Assertion |
    SecurityPermissionFlag.ControlAppDomain,
    SecurityPermissionFlag.ControlAppDomain,
    SecurityPermissionFlag.ControlDomainPolicy |
    SecurityPermissionFlag.ControlEvidence,
    SecurityPermissionFlag.ControlEvidence,
    SecurityPermissionFlag.ControlPolicy |
    SecurityPermissionFlag.ControlPrincipal,
    SecurityPermissionFlag.ControlPrincipal,
    SecurityPermissionFlag.ControlThread,
    SecurityPermissionFlag.Execution,
    SecurityPermissionFlag.Infrastructure,
    SecurityPermissionFlag.NoFlags,
    SecurityPermissionFlag.RemotingConfiguration |
    SecurityPermissionFlag.SerializationFormatter,
    SecurityPermissionFlag.SerializationFormatter,
    SecurityPermissionFlag.SkipVerification,
    SecurityPermissionFlag.UnmanagedCode};

    private int reflectionIndex = 0;

    public SecurityGenerator()
    {
        ResetIndex();
    }

    public void ResetIndex()
    {
        reflectionIndex = 0;
    }
    // GetSecurityFlag returns a SecurityPermissionFlag.
    public bool GetSecurityFlag(out SecurityPermissionFlag security)
    {

        if(reflectionIndex >= mySecurity.Length)
        {

            security = SecurityPermissionFlag.NoFlags;
            reflectionIndex++;
            return false;
        }
        security = mySecurity[reflectionIndex++];
            return true;

    }
} //

import System.*;
import System.Security.*;
import System.Security.Permissions.*;

/** @assembly CLSCompliant(true)
 */

public class SecurityPermissionDemo
{
    // IsSubsetOf determines whether the current permission is a 
    // subset of the specified permission.
    private boolean IsSubsetOfDemo() 
    {
        boolean returnValue = true;
        SecurityPermissionFlag security1[] = new SecurityPermissionFlag[1];
        SecurityPermissionFlag security2[] = new SecurityPermissionFlag[1];
        SecurityPermission securityPerm1[] = new SecurityPermission[1];
        SecurityPermission securityPerm2[] = new SecurityPermission[1];
        SecurityGenerator securityGen1 = new SecurityGenerator();
        SecurityGenerator securityGen2 = new SecurityGenerator();
        securityGen1.ResetIndex();
        
        while (securityGen1.CreateSecurity(securityPerm1, security1)) {
            if (securityPerm1[0] == null) {
                continue ;
            }
            securityGen2.ResetIndex();
            Console.WriteLine("****************************" 
                + "****************************\n");
            
            while (securityGen2.CreateSecurity(securityPerm2, security2)) {
                if (securityPerm2[0] == null) {
                    continue ;
                }
                try {
                    if (securityPerm1[0].IsSubsetOf(securityPerm2[0])) {
                        Console.WriteLine((securityPerm1[0].get_Flags() 
                            + " is a subset of " 
                            + securityPerm2[0].get_Flags()));
                    }
                    else {
                        Console.WriteLine((securityPerm1[0].get_Flags() 
                            + " is not a subset of " 
                            + securityPerm2[0].get_Flags()));
                    }
                }
                catch(System.Exception e) { 
                    Console.WriteLine(("An exception was " 
                        + "thrown for subset :" + securityPerm1[0] 
                        + "\n" + securityPerm2[0] + "\n" + e));
                    returnValue = false;
                }
            }
        }
        return returnValue ;
    } //IsSubsetOfDemo

    // Union creates a new permission that is the union of the 
    // current permission and the specified permission.
    private boolean UnionDemo() 
    {
        boolean returnValue = true;
        SecurityPermissionFlag security1[] = new SecurityPermissionFlag[1];
        SecurityPermissionFlag security2[] = new SecurityPermissionFlag[1];
        SecurityPermission securityPerm1[] = new SecurityPermission[1];
        SecurityPermission securityPerm2[] = new SecurityPermission[1];
        IPermission securityPerm3;
        SecurityGenerator securityGen1 = new SecurityGenerator();
        SecurityGenerator securityGen2 = new SecurityGenerator();
        securityGen1.ResetIndex();

        while (securityGen1.CreateSecurity(securityPerm1, security1)) {
            if (securityPerm1[0] == null) {
                continue ;
            }
            Console.WriteLine("*******************************" 
                + "***************************\n");
            securityGen2.ResetIndex();
            
            while (securityGen2.CreateSecurity(securityPerm2, security2)) {
                if (securityPerm2[0] == null) {
                    continue ;
                }
                securityPerm3 =((SecurityPermission)(securityPerm1[0].
                    Union(securityPerm2[0])));
                securityPerm3 = securityPerm1[0].Union(securityPerm2[0]);
                
                if (securityPerm3 == null) {
                    Console.WriteLine(("The union of "     + security1[0] 
                    + " and " + security2[0] + " is null."));
                }
                else {
                    Console.WriteLine(("The union of " 
                        + securityPerm1[0].get_Flags() 
                        + " and " + securityPerm2[0].get_Flags() + " = " 
                        + ((SecurityPermission)(securityPerm3)).
                        get_Flags().ToString()));
                }
            }
        }return returnValue ;
    } //UnionDemo    

    // Intersect creates and returns a new permission that is the 
    // intersection of the current
    // permission and the permission specified.
    private boolean IntersectDemo() 
    {
        boolean returnValue = true;
        SecurityPermissionFlag security1[] = new SecurityPermissionFlag[1];
        SecurityPermissionFlag security2[] = new SecurityPermissionFlag[1];
        SecurityPermission securityPerm1[] = new SecurityPermission[1];
        SecurityPermission securityPerm2[] = new SecurityPermission[1];
        SecurityPermission securityPerm3;
        SecurityGenerator securityGen1 =  new SecurityGenerator();
        SecurityGenerator securityGen2 =  new SecurityGenerator();
        securityGen1.ResetIndex();
        while (securityGen1.CreateSecurity(securityPerm1, security1)) {
            if (securityPerm1[0] == null) {
                continue ;
            }
            Console.WriteLine("********************************" 
                + "**************************\n");
            securityGen2.ResetIndex();
            
            while (securityGen2.CreateSecurity(securityPerm2, security2)) {
                if (securityPerm2[0] == null) {
                    continue ;
                }
                
                securityPerm3 =((SecurityPermission)(
                securityPerm1[0].Intersect(securityPerm2[0])));
                if (securityPerm3 != null) {
                    Console.WriteLine(("The intersection of " 
                        + security1[0] + " and " + security2[0] + " = " 
                        + ((SecurityPermission)(securityPerm3)).
                        get_Flags().ToString()));
                }
                else {
                    Console.WriteLine(("The intersection of " 
                        + security1[0] + " and " + security2[0] + " is null."));
                }
            }
        }      
        return returnValue ;
    } //IntersectDemo

    //Copy creates and returns an identical copy of the current permission.
    private boolean CopyDemo() 
    {
        boolean returnValue = true;
        
        SecurityPermissionFlag security1[] = new SecurityPermissionFlag[1];
        SecurityPermission securityPerm1[] = new SecurityPermission[1];
        SecurityPermission securityPerm2[] = new SecurityPermission[1];
        
        SecurityGenerator securityGen1 =  new SecurityGenerator();
        SecurityGenerator securityGen2 =  new SecurityGenerator();
        
        securityGen1.ResetIndex();
        while (securityGen1.CreateSecurity(securityPerm1, security1)) {
            if (securityPerm1[0] == null) {
                continue ;
            }
            securityGen2.ResetIndex();
            Console.WriteLine("***************************************" 
                + "*****************\n");
            try {
                securityPerm2[0] =((SecurityPermission)(
                    securityPerm1[0].Copy()));
                Console.WriteLine(("Result of copy = " 
                    + securityPerm2[0].ToString()));
            } 
            catch(System.Exception e) {
                Console.WriteLine(("Copy failed :" 
                    + securityPerm1[0].ToString() + e));
                continue ;
            }
        }
        return returnValue ;
    } //CopyDemo

    // ToXml creates an XML encoding of the permission and its current state;
    // FromXml reconstructs a permission with the specified state 
    // from the XML encoding.
    private boolean ToFromXmlDemo() 
    {
        boolean returnValue = true;
           SecurityPermissionFlag security1[] = new SecurityPermissionFlag[1];
        SecurityPermission securityPerm1[] = new SecurityPermission[1];
        SecurityPermission securityPerm2[] = new SecurityPermission[1];
        SecurityGenerator securityGen1 =  new SecurityGenerator();
        SecurityGenerator securityGen2 =  new SecurityGenerator();
        securityGen1.ResetIndex();
        while (securityGen1.CreateSecurity(securityPerm1, security1)) {
            if (securityPerm1[0] == null) {
                continue ;
            }
            Console.WriteLine("*****************************" 
                + "***************************\n");
            securityGen2.ResetIndex();
            try {
                securityPerm2[0] = 
                    new SecurityPermission(PermissionState.None);
                securityPerm2[0].FromXml(securityPerm1[0].ToXml());
                Console.WriteLine(("Result of ToFromXml = " 
                    + securityPerm2[0].ToString()));
            }        
            catch(System.Exception e) {
                Console.WriteLine(("ToFromXml failed :" 
                    + securityPerm1[0].ToString() + e));
                continue ;
            }
        }      
        return returnValue ;
    } //ToFromXmlDemo

    // Invoke all demos.
    public boolean runDemo() 
    {
        boolean returnCode = true;
        boolean tempReturnCode;
        
        // Call the IsSubsetOf demo.
        tempReturnCode = IsSubsetOfDemo();
        if (tempReturnCode) {
            Console.get_Out().WriteLine("IsSubsetOf demo " 
                + "completed successfully.");
        }
        else {
            Console.get_Out().WriteLine("IsSubsetOf demo failed.");
        }
        returnCode = tempReturnCode && returnCode;
        
        // Call the Union demo.
        tempReturnCode = UnionDemo();
        if (tempReturnCode) {
            Console.get_Out().WriteLine("Union demo completed successfully.");
        }
        else {
            Console.get_Out().WriteLine("Union demo failed.");
        }
        returnCode = tempReturnCode && returnCode;
        
        // Call the Intersect demo.
        tempReturnCode = IntersectDemo();
        if (tempReturnCode) {
            Console.get_Out().WriteLine("Intersect demo " 
                + "completed successfully.");
        }
        else {
            Console.get_Out().WriteLine("Intersect demo failed.");
        }
        returnCode = tempReturnCode && returnCode;
        
        
        // Call the Copy demo.
        tempReturnCode = CopyDemo();
        if (tempReturnCode) {
            Console.get_Out().WriteLine("Copy demo completed successfully.");
        }
        else {
            Console.get_Out().WriteLine("Copy demo failed.");
        }
        returnCode = tempReturnCode && returnCode;
        
        // Call the ToFromXml demo.
        tempReturnCode = ToFromXmlDemo();
        if (tempReturnCode) {
            Console.get_Out().WriteLine("ToFromXml demo " 
                + "completed successfully.");
        }
        else {
            Console.get_Out().WriteLine("ToFromXml demo failed.");
        }
        returnCode = tempReturnCode && returnCode;      
        return returnCode ;
    } //runDemo

    // Test harness.
    public static void main(String[] args)
    {
        try {
            SecurityPermissionDemo democase =  new SecurityPermissionDemo();
            boolean returnCode = democase.runDemo();
            if (returnCode) {
                Console.get_Out().WriteLine("SecurityPermission demo " 
                    + "completed successfully.");
                Console.get_Out().WriteLine("Press the Enter key to exit.");
                String consoleInput = Console.ReadLine();
                System.Environment.set_ExitCode(100);
            }
            else {
                Console.get_Out().WriteLine("SecurityPermission demo failed.");
                Console.get_Out().WriteLine("Press the Enter key to exit.");
                String consoleInput = Console.ReadLine();
                System.Environment.set_ExitCode(101);
            }
        }
        catch (System.Exception e) {
              Console.get_Out().WriteLine("SecurityPermission demo failed.");
            Console.WriteLine(e.ToString());
            Console.get_Out().WriteLine("Press the Enter key to exit.");
            String consoleInput = Console.ReadLine();
            System.Environment.set_ExitCode(101);
        }
    } //main
} //SecurityPermissionDemo

// This class generates SecurityPermission objects.
class SecurityGenerator
{
    private SecurityPermissionFlag mySecurity[] =  
        {
        SecurityPermissionFlag.AllFlags, 
        SecurityPermissionFlag.Assertion, 
        SecurityPermissionFlag.ControlAppDomain, 
        SecurityPermissionFlag.ControlDomainPolicy, 
        SecurityPermissionFlag.ControlEvidence, 
        SecurityPermissionFlag.ControlPolicy, 
        SecurityPermissionFlag.ControlPrincipal, 
        SecurityPermissionFlag.ControlThread, 
        SecurityPermissionFlag.Execution, 
        SecurityPermissionFlag.Infrastructure, 
        SecurityPermissionFlag.NoFlags, 
        SecurityPermissionFlag.RemotingConfiguration, 
        SecurityPermissionFlag.SerializationFormatter, 
        SecurityPermissionFlag.SkipVerification, 
        SecurityPermissionFlag.UnmanagedCode
        };   
    
    private int reflectionIndex = 0;   

    public SecurityGenerator() 
    {
        ResetIndex();
    } //SecurityGenerator

    public void ResetIndex() 
    {
        reflectionIndex = 0;
    } //ResetIndex

    // CreateSecurity creates a SecurityPermission object.
    public boolean CreateSecurity(
        SecurityPermission securityPerm[], SecurityPermissionFlag security[]) 
    {
        if (reflectionIndex >= mySecurity.length) {
            securityPerm[0] = new SecurityPermission(PermissionState.None);
            security[0] = SecurityPermissionFlag.NoFlags;
            reflectionIndex++;
            return false ;
        }
        security[0] = mySecurity[reflectionIndex++];
        try {
            securityPerm[0] = new SecurityPermission(security[0]);
            return true ;
        }
        catch(System.Exception e) {
            Console.WriteLine(("Cannot create SecurityPermission: " 
                + security[0] + " " + e));
            securityPerm[0] = new SecurityPermission(PermissionState.None);
            security[0] = SecurityPermissionFlag.NoFlags;
            return true ;
        }
    } //CreateSecurity
} //SecurityGenerator

System.Object
   System.Security.CodeAccessPermission
    System.Security.Permissions.SecurityPermission

Les membres statiques publics (Shared en Visual Basic) de ce type sont thread-safe. Il n'est pas garanti que les membres d'instance soient thread-safe.

Windows 98, Windows 2000 SP4, Windows Millennium Edition, Windows Server 2003, Windows XP Édition Media Center, Windows XP Professionnel Édition x64, Windows XP SP2, Windows XP Starter Edition

Le .NET Framework ne prend pas en charge toutes les versions de chaque plate-forme. Pour obtenir la liste des versions prises en charge, consultez Configuration requise.

.NET Framework

Prise en charge dans : 2.0, 1.1, 1.0
Afficher: