Esta documentación está archivada y no tiene mantenimiento.

SecurityPermission (Clase)

Describe un conjunto de permisos de seguridad aplicados a código. No se puede heredar esta clase.

Espacio de nombres: System.Security.Permissions
Ensamblado: mscorlib (en 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

Este permiso utiliza la enumeración SecurityPermissionFlag. Los valores de esta enumeración se pueden encontrar en la documentación correspondiente.

En el ejemplo de código siguiente se muestra el comportamiento de los métodos de la clase SecurityPermission. La intención del ejemplo es mostrar los resultados de los métodos, no cómo se utilizan los métodos normalmente. Para obtener un ejemplo que muestre el uso de la clase SecurityPermission de cara a solicitar el permiso para un valor concreto de la enumeración SecurityPermissionFlag, vea el constructor 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

Los miembros estáticos públicos (Shared en Visual Basic) de este tipo son seguros para la ejecución de subprocesos. No se garantiza que los miembros de instancias sean seguros para la ejecución de subprocesos.

Windows 98, Windows 2000 SP4, Windows Millennium, Windows Server 2003, Windows XP Media Center, Windows XP Professional x64, Windows XP SP2, Windows XP Starter Edition

.NET Framework no admite todas las versiones de cada plataforma. Para obtener una lista de las versiones admitidas, vea Requisitos del sistema.

.NET Framework

Compatible con: 2.0, 1.1, 1.0
Mostrar: