WindowsIdentity Classe

Définition

Représente un utilisateur Windows.

public ref class WindowsIdentity : System::Security::Claims::ClaimsIdentity, IDisposable, System::Runtime::Serialization::IDeserializationCallback, System::Runtime::Serialization::ISerializable
public ref class WindowsIdentity : System::Security::Claims::ClaimsIdentity, IDisposable
public ref class WindowsIdentity : System::Runtime::Serialization::IDeserializationCallback, System::Runtime::Serialization::ISerializable, System::Security::Principal::IIdentity
public ref class WindowsIdentity : IDisposable, System::Runtime::Serialization::IDeserializationCallback, System::Runtime::Serialization::ISerializable, System::Security::Principal::IIdentity
public class WindowsIdentity : System.Security.Claims.ClaimsIdentity, IDisposable, System.Runtime.Serialization.IDeserializationCallback, System.Runtime.Serialization.ISerializable
public class WindowsIdentity : System.Security.Claims.ClaimsIdentity, IDisposable
[System.Serializable]
public class WindowsIdentity : System.Runtime.Serialization.IDeserializationCallback, System.Runtime.Serialization.ISerializable, System.Security.Principal.IIdentity
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public class WindowsIdentity : IDisposable, System.Runtime.Serialization.IDeserializationCallback, System.Runtime.Serialization.ISerializable, System.Security.Principal.IIdentity
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public class WindowsIdentity : System.Security.Claims.ClaimsIdentity, IDisposable, System.Runtime.Serialization.IDeserializationCallback, System.Runtime.Serialization.ISerializable
type WindowsIdentity = class
    inherit ClaimsIdentity
    interface IDisposable
    interface ISerializable
    interface IDeserializationCallback
type WindowsIdentity = class
    inherit ClaimsIdentity
    interface IDisposable
    interface IDeserializationCallback
    interface ISerializable
type WindowsIdentity = class
    inherit ClaimsIdentity
    interface IDisposable
[<System.Serializable>]
type WindowsIdentity = class
    interface IIdentity
    interface ISerializable
    interface IDeserializationCallback
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type WindowsIdentity = class
    interface IIdentity
    interface ISerializable
    interface IDeserializationCallback
    interface IDisposable
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type WindowsIdentity = class
    inherit ClaimsIdentity
    interface ISerializable
    interface IDeserializationCallback
    interface IDisposable
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type WindowsIdentity = class
    inherit ClaimsIdentity
    interface IIdentity
    interface IDeserializationCallback
    interface ISerializable
    interface IDisposable
Public Class WindowsIdentity
Inherits ClaimsIdentity
Implements IDeserializationCallback, IDisposable, ISerializable
Public Class WindowsIdentity
Inherits ClaimsIdentity
Implements IDisposable
Public Class WindowsIdentity
Implements IDeserializationCallback, IIdentity, ISerializable
Public Class WindowsIdentity
Implements IDeserializationCallback, IDisposable, IIdentity, ISerializable
Héritage
WindowsIdentity
Héritage
WindowsIdentity
Attributs
Implémente

Exemples

L’exemple suivant illustre l’utilisation des membres de la WindowsIdentity classe. pour obtenir un exemple illustrant l’obtention d’un jeton de compte Windows via un appel à la fonction Win32 non managée LogonUser et l’utilisation de ce jeton pour emprunter l’identité d’un autre utilisateur, consultez la WindowsImpersonationContext classe.

using namespace System;
using namespace System::Security::Principal;
void IntPtrConstructor( IntPtr logonToken );
void IntPtrStringConstructor( IntPtr logonToken );
void IntPrtStringTypeBoolConstructor( IntPtr logonToken );
void IntPtrStringTypeConstructor( IntPtr logonToken );
void UseProperties( IntPtr logonToken );
IntPtr LogonUser();
void GetAnonymousUser();
void ImpersonateIdentity( IntPtr logonToken );

[STAThread]
int main()
{
   
   // Retrieve the Windows account token for the current user.
   IntPtr logonToken = LogonUser();
   
   // Constructor implementations.
   IntPtrConstructor( logonToken );
   IntPtrStringConstructor( logonToken );
   IntPtrStringTypeConstructor( logonToken );
   IntPrtStringTypeBoolConstructor( logonToken );
   
   // Property implementations.
   UseProperties( logonToken );
   
   // Method implementations.
   GetAnonymousUser();
   ImpersonateIdentity( logonToken );
   Console::WriteLine( "This sample completed successfully; "
   "press Enter to exit." );
   Console::ReadLine();
}


// Create a WindowsIdentity object for the user represented by the
// specified Windows account token.
void IntPtrConstructor( IntPtr logonToken )
{
   
   // Construct a WindowsIdentity object using the input account token.
   WindowsIdentity^ windowsIdentity = gcnew WindowsIdentity( logonToken );
   
   Console::WriteLine( "Created a Windows identity object named {0}.", windowsIdentity->Name );
}

// Create a WindowsIdentity object for the user represented by the
// specified account token and authentication type.
void IntPtrStringConstructor( IntPtr logonToken )
{
   
   // Construct a WindowsIdentity object using the input account token 
   // and the specified authentication type.
   String^ authenticationType = "WindowsAuthentication";
   WindowsIdentity^ windowsIdentity = gcnew WindowsIdentity( logonToken,authenticationType );
   
   Console::WriteLine( "Created a Windows identity object named {0}.", windowsIdentity->Name );
}



// Create a WindowsIdentity object for the user represented by the
// specified account token, authentication type and Windows account
// type.
void IntPtrStringTypeConstructor( IntPtr logonToken )
{
   
   // Construct a WindowsIdentity object using the input account token,
   // and the specified authentication type and Windows account type.
   String^ authenticationType = "WindowsAuthentication";
   WindowsAccountType guestAccount = WindowsAccountType::Guest;
   WindowsIdentity^ windowsIdentity = gcnew WindowsIdentity( logonToken,authenticationType,guestAccount );
   
   Console::WriteLine( "Created a Windows identity object named {0}.", windowsIdentity->Name );
}

// Create a WindowsIdentity object for the user represented by the
// specified account token, authentication type, Windows account type and
// Boolean authentication flag.
void IntPrtStringTypeBoolConstructor( IntPtr logonToken )
{
   
   // Construct a WindowsIdentity object using the input account token,
   // and the specified authentication type, Windows account type, and
   // authentication flag.
   String^ authenticationType = "WindowsAuthentication";
   WindowsAccountType guestAccount = WindowsAccountType::Guest;
   bool isAuthenticated = true;
   WindowsIdentity^ windowsIdentity = gcnew WindowsIdentity( logonToken,authenticationType,guestAccount,isAuthenticated );
   
   Console::WriteLine( "Created a Windows identity object named {0}.", windowsIdentity->Name );
}

// Access the properties of a WindowsIdentity object.
void UseProperties( IntPtr logonToken )
{
   WindowsIdentity^ windowsIdentity = gcnew WindowsIdentity( logonToken );
   String^ propertyDescription = "The windows identity named ";
   
   // Retrieve the Windows logon name from the Windows identity object.
   propertyDescription = String::Concat( propertyDescription, windowsIdentity->Name );
   
   // Verify that the user account is not considered to be an Anonymous
   // account by the system.
   if (  !windowsIdentity->IsAnonymous )
   {
      propertyDescription = String::Concat( propertyDescription, ", is not an Anonymous account" );
   }

   
   // Verify that the user account has been authenticated by Windows.
   if ( windowsIdentity->IsAuthenticated )
   {
      propertyDescription = String::Concat( propertyDescription, ", is authenticated" );
   }
   
   // Verify that the user account is considered to be a System account
   // by the system.
   if ( windowsIdentity->IsSystem )
   {
      propertyDescription = String::Concat( propertyDescription, ", is a System account" );
   }
   
   // Verify that the user account is considered to be a Guest account
   // by the system.
   if ( windowsIdentity->IsGuest )
   {
      propertyDescription = String::Concat( propertyDescription, ", is a Guest account" );
   }
   
   // Retrieve the authentication type for the 
   String^ authenticationType = windowsIdentity->AuthenticationType;
   
   // Append the authenication type to the output message.
   if ( authenticationType != nullptr )
   {
      propertyDescription = String::Format( "{0} and uses {1} authentication type.", propertyDescription, authenticationType );
   }
   
   Console::WriteLine( propertyDescription );
}


// Retrieve the account token from the current WindowsIdentity object
// instead of calling the unmanaged LogonUser method in the advapi32.dll.
IntPtr LogonUser()
{
   
   IntPtr accountToken = WindowsIdentity::GetCurrent()->Token;
   
   return accountToken;
}


// Get the WindowsIdentity object for an Anonymous user.
void GetAnonymousUser()
{
   
   // Retrieve a WindowsIdentity object that represents an anonymous
   // Windows user.
   WindowsIdentity^ windowsIdentity = WindowsIdentity::GetAnonymous();
   
}


// Impersonate a Windows identity.
void ImpersonateIdentity( IntPtr logonToken )
{
   
   // Retrieve the Windows identity using the specified token.
   WindowsIdentity^ windowsIdentity = gcnew WindowsIdentity( logonToken );
   
   // Create a WindowsImpersonationContext object by impersonating the
   // Windows identity.
   WindowsImpersonationContext^ impersonationContext = windowsIdentity->Impersonate();
   Console::WriteLine( "Name of the identity after impersonation: {0}.", WindowsIdentity::GetCurrent()->Name );
   
   // Stop impersonating the user.
   impersonationContext->Undo();
   
   // Check the identity name.
   Console::Write( "Name of the identity after performing an Undo on the" );
   Console::WriteLine( " impersonation: {0}", WindowsIdentity::GetCurrent()->Name );
}
using System;
using System.Security.Principal;

class WindowsIdentityMembers
{
    [STAThread]
    static void Main(string[] args)
    {
        // Retrieve the Windows account token for the current user.
        IntPtr logonToken = LogonUser();

        // Constructor implementations.
        IntPtrConstructor(logonToken);
        IntPtrStringConstructor(logonToken);
        IntPtrStringTypeConstructor(logonToken);
        IntPrtStringTypeBoolConstructor(logonToken);

        // Property implementations.
        UseProperties(logonToken);

        // Method implementations.
        GetAnonymousUser();
        ImpersonateIdentity(logonToken);

        Console.WriteLine("This sample completed successfully; " +
            "press Enter to exit.");
        Console.ReadLine();
    }

    // Create a WindowsIdentity object for the user represented by the
    // specified Windows account token.
    private static void IntPtrConstructor(IntPtr logonToken)
    {
        // Construct a WindowsIdentity object using the input account token.
        WindowsIdentity windowsIdentity = new WindowsIdentity(logonToken);

        Console.WriteLine("Created a Windows identity object named " +
            windowsIdentity.Name + ".");
    }

    // Create a WindowsIdentity object for the user represented by the
    // specified account token and authentication type.
    private static void IntPtrStringConstructor(IntPtr logonToken)
    {
        // Construct a WindowsIdentity object using the input account token 
        // and the specified authentication type.
        string authenticationType = "WindowsAuthentication";
        WindowsIdentity windowsIdentity =
                        new WindowsIdentity(logonToken, authenticationType);

        Console.WriteLine("Created a Windows identity object named " +
            windowsIdentity.Name + ".");
    }

    // Create a WindowsIdentity object for the user represented by the
    // specified account token, authentication type, and Windows account
    // type.
    private static void IntPtrStringTypeConstructor(IntPtr logonToken)
    {
        // Construct a WindowsIdentity object using the input account token,
        // and the specified authentication type, and Windows account type.
        string authenticationType = "WindowsAuthentication";
        WindowsAccountType guestAccount = WindowsAccountType.Guest;
        WindowsIdentity windowsIdentity =
            new WindowsIdentity(logonToken, authenticationType, guestAccount);

        Console.WriteLine("Created a Windows identity object named " +
            windowsIdentity.Name + ".");
    }

    // Create a WindowsIdentity object for the user represented by the
    // specified account token, authentication type, Windows account type, and
    // Boolean authentication flag.
    private static void IntPrtStringTypeBoolConstructor(IntPtr logonToken)
    {
        // Construct a WindowsIdentity object using the input account token,
        // and the specified authentication type, Windows account type, and
        // authentication flag.
        string authenticationType = "WindowsAuthentication";
        WindowsAccountType guestAccount = WindowsAccountType.Guest;
        bool isAuthenticated = true;
        WindowsIdentity windowsIdentity = new WindowsIdentity(
            logonToken, authenticationType, guestAccount, isAuthenticated);

        Console.WriteLine("Created a Windows identity object named " +
            windowsIdentity.Name + ".");
    }
    // Access the properties of a WindowsIdentity object.
    private static void UseProperties(IntPtr logonToken)
    {
        WindowsIdentity windowsIdentity = new WindowsIdentity(logonToken);
        string propertyDescription = "The Windows identity named ";

        // Retrieve the Windows logon name from the Windows identity object.
        propertyDescription += windowsIdentity.Name;

        // Verify that the user account is not considered to be an Anonymous
        // account by the system.
        if (!windowsIdentity.IsAnonymous)
        {
            propertyDescription += " is not an Anonymous account";
        }

        // Verify that the user account has been authenticated by Windows.
        if (windowsIdentity.IsAuthenticated)
        {
            propertyDescription += ", is authenticated";
        }

        // Verify that the user account is considered to be a System account
        // by the system.
        if (windowsIdentity.IsSystem)
        {
            propertyDescription += ", is a System account";
        }
        // Verify that the user account is considered to be a Guest account
        // by the system.
        if (windowsIdentity.IsGuest)
        {
            propertyDescription += ", is a Guest account";
        }

        // Retrieve the authentication type for the 
        String authenticationType = windowsIdentity.AuthenticationType;

        // Append the authenication type to the output message.
        if (authenticationType != null)
        {
            propertyDescription += (" and uses " + authenticationType);
            propertyDescription += (" authentication type.");
        }

        Console.WriteLine(propertyDescription);

        // Display the SID for the owner.
        Console.Write("The SID for the owner is : ");
        SecurityIdentifier si = windowsIdentity.Owner;
        Console.WriteLine(si.ToString());
        // Display the SIDs for the groups the current user belongs to.
        Console.WriteLine("Display the SIDs for the groups the current user belongs to.");
        IdentityReferenceCollection irc = windowsIdentity.Groups;
        foreach (IdentityReference ir in irc)
            Console.WriteLine(ir.Value);
        TokenImpersonationLevel token = windowsIdentity.ImpersonationLevel;
        Console.WriteLine("The impersonation level for the current user is : " + token.ToString());
    }

    // Retrieve the account token from the current WindowsIdentity object
    // instead of calling the unmanaged LogonUser method in the advapi32.dll.
    private static IntPtr LogonUser()
    {
        IntPtr accountToken = WindowsIdentity.GetCurrent().Token;
        Console.WriteLine( "Token number is: " + accountToken.ToString());

        return accountToken;
    }

    // Get the WindowsIdentity object for an Anonymous user.
    private static void GetAnonymousUser()
    {
        // Retrieve a WindowsIdentity object that represents an anonymous
        // Windows user.
        WindowsIdentity windowsIdentity = WindowsIdentity.GetAnonymous();
    }

    // Impersonate a Windows identity.
    private static void ImpersonateIdentity(IntPtr logonToken)
    {
        // Retrieve the Windows identity using the specified token.
        WindowsIdentity windowsIdentity = new WindowsIdentity(logonToken);

        // Create a WindowsImpersonationContext object by impersonating the
        // Windows identity.
        WindowsImpersonationContext impersonationContext =
            windowsIdentity.Impersonate();

        Console.WriteLine("Name of the identity after impersonation: "
            + WindowsIdentity.GetCurrent().Name + ".");
        Console.WriteLine(windowsIdentity.ImpersonationLevel);
        // Stop impersonating the user.
        impersonationContext.Undo();

        // Check the identity name.
        Console.Write("Name of the identity after performing an Undo on the");
        Console.WriteLine(" impersonation: " +
            WindowsIdentity.GetCurrent().Name);
    }
}
Imports System.Security.Principal

Module Module1

    Sub Main()

        ' Retrieve the Windows account token for the current user.
        Dim logonToken As IntPtr = LogonUser()

        ' Constructor implementations.
        IntPtrConstructor(logonToken)
        IntPtrStringConstructor(logonToken)
        IntPtrStringTypeConstructor(logonToken)
        IntPrtStringTypeBoolConstructor(logonToken)

        ' Property implementations.
        UseProperties(logonToken)

        ' Method implementations.
        GetAnonymousUser()
        ImpersonateIdentity(logonToken)

        ' Align interface and conclude application.
        Console.WriteLine(vbCrLf + "This sample completed " + _
            "successfully; press Enter to exit.")
        Console.ReadLine()

    End Sub
    
    ' Create a WindowsIdentity object for the user represented by the
    ' specified Windows account token.
    Private Sub IntPtrConstructor(ByVal logonToken As IntPtr)
        ' Construct a WindowsIdentity object using the input account token.
        Dim windowsIdentity As New WindowsIdentity(logonToken)

        WriteLine("Created a Windows identity object named " + _
            windowsIdentity.Name + ".")
    End Sub
    ' Create a WindowsIdentity object for the user represented by the
    ' specified account token and authentication type.
    Private Sub IntPtrStringConstructor(ByVal logonToken As IntPtr)
        ' Construct a WindowsIdentity object using the input account token 
        ' and the specified authentication type
        Dim authenticationType = "WindowsAuthentication"
        Dim windowsIdentity As _
            New WindowsIdentity(logonToken, authenticationType)

        WriteLine("Created a Windows identity object named " + _
            windowsIdentity.Name + ".")
    End Sub

    ' Create a WindowsIdentity object for the user represented by the
    ' specified account token, authentication type, and Windows account
    ' type.
    Private Sub IntPtrStringTypeConstructor(ByVal logonToken As IntPtr)
        ' Construct a WindowsIdentity object using the input account token,
        ' and the specified authentication type and Windows account type.
        Dim authenticationType As String = "WindowsAuthentication"
        Dim guestAccount As WindowsAccountType = WindowsAccountType.Guest
        Dim windowsIdentity As _
            New WindowsIdentity(logonToken, authenticationType, guestAccount)

        WriteLine("Created a Windows identity object named " + _
            windowsIdentity.Name + ".")
    End Sub

    ' Create a WindowsIdentity object for the user represented by the
    ' specified account token, authentication type, Windows account type,
    ' and Boolean authentication flag.
    Private Sub IntPrtStringTypeBoolConstructor(ByVal logonToken As IntPtr)
        ' Construct a WindowsIdentity object using the input account token,
        ' and the specified authentication type, Windows account type, and
        ' authentication flag.
        Dim authenticationType As String = "WindowsAuthentication"
        Dim guestAccount As WindowsAccountType = WindowsAccountType.Guest
        Dim isAuthenticated As Boolean = True
        Dim windowsIdentity As New WindowsIdentity( _
            logonToken, authenticationType, guestAccount, isAuthenticated)

        WriteLine("Created a Windows identity object named " + _
            windowsIdentity.Name + ".")
    End Sub
        
    ' Access the properties of a WindowsIdentity object.
    Private Sub UseProperties(ByVal logonToken As IntPtr)
        Dim windowsIdentity As New WindowsIdentity(logonToken)
        Dim propertyDescription As String = "The Windows identity named "

        ' Retrieve the Windows logon name from the Windows identity object.
        propertyDescription += windowsIdentity.Name

        ' Verify that the user account is not considered to be an Anonymous
        ' account by the system.
        If Not windowsIdentity.IsAnonymous Then
            propertyDescription += " is not an Anonymous account"
        End If

        ' Verify that the user account has been authenticated by Windows.
        If (windowsIdentity.IsAuthenticated) Then
            propertyDescription += ", is authenticated"
        End If

        ' Verify that the user account is considered to be a System account by
        ' the system.
        If (windowsIdentity.IsSystem) Then
            propertyDescription += ", is a System account"
        End If

        ' Verify that the user account is considered to be a Guest account by
        ' the system.
        If (windowsIdentity.IsGuest) Then
            propertyDescription += ", is a Guest account"
        End If
        Dim authenticationType As String = windowsIdentity.AuthenticationType

        ' Append the authenication type to the output message.
        If (Not authenticationType Is Nothing) Then
            propertyDescription += (" and uses " + authenticationType)
            propertyDescription += (" authentication type.")
        End If

        WriteLine(propertyDescription)

        ' Display the SID for the owner.
        Console.Write("The SID for the owner is : ")
        Dim si As SecurityIdentifier
        si = windowsIdentity.Owner
        Console.WriteLine(si.ToString())
        ' Display the SIDs for the groups the current user belongs to.
        Console.WriteLine("Display the SIDs for the groups the current user belongs to.")
        Dim irc As IdentityReferenceCollection
        Dim ir As IdentityReference
        irc = windowsIdentity.Groups
        For Each ir In irc
            Console.WriteLine(ir.Value)
        Next
        Dim token As TokenImpersonationLevel
        token = windowsIdentity.ImpersonationLevel
        Console.WriteLine("The impersonation level for the current user is : " + token.ToString())
    End Sub
    ' Retrieve the account token from the current WindowsIdentity object
    ' instead of calling the unmanaged LogonUser method in the advapi32.dll.
    Private Function LogonUser() As IntPtr
        Dim accountToken As IntPtr = WindowsIdentity.GetCurrent().Token

        Return accountToken
    End Function

    ' Get the WindowsIdentity object for an Anonymous user.
    Private Sub GetAnonymousUser()
        ' Retrieve a WindowsIdentity object that represents an anonymous
        ' Windows user.
        Dim windowsIdentity As WindowsIdentity
        windowsIdentity = windowsIdentity.GetAnonymous()
    End Sub

    ' Impersonate a Windows identity.
    Private Sub ImpersonateIdentity(ByVal logonToken As IntPtr)
        ' Retrieve the Windows identity using the specified token.
        Dim windowsIdentity As New WindowsIdentity(logonToken)

        ' Create a WindowsImpersonationContext object by impersonating the
        ' Windows identity.
        Dim impersonationContext As WindowsImpersonationContext
        impersonationContext = windowsIdentity.Impersonate()

        WriteLine("Name of the identity after impersonation: " + _
            windowsIdentity.GetCurrent().Name + ".")

        ' Stop impersonating the user.
        impersonationContext.Undo()

        ' Check the identity.
        WriteLine("Name of the identity after performing an Undo on the " + _
            "impersonation: " + windowsIdentity.GetCurrent().Name + ".")
    End Sub
    ' Write out message with carriage return to output textbox.
    Private Sub WriteLine(ByVal message As String)
        Console.WriteLine(message + vbCrLf)
    End Sub

End Module

Remarques

Appelez la GetCurrent méthode pour créer un WindowsIdentity objet qui représente l’utilisateur actuel.

Important

Ce type implémente l'interface IDisposable. Une fois que vous avez fini d’utiliser le type, vous devez le supprimer directement ou indirectement. Pour supprimer directement le type Dispose, appelez sa méthode dans un bloc try/catch. Pour la supprimer indirectement, utilisez une construction de langage telle que using (dans C#) ou Using (dans Visual Basic). Pour plus d’informations, consultez la section « Utilisation d’un objet qui implémente IDisposable » dans la rubrique de l’interface IDisposable.

Constructeurs

WindowsIdentity(IntPtr)

Initialise une nouvelle instance de la classe WindowsIdentity pour l'utilisateur représenté par le jeton de compte Windows spécifié.

WindowsIdentity(IntPtr, String)

Initialise une nouvelle instance de la classe WindowsIdentity pour l'utilisateur représenté par le jeton de compte Windows et le type d'authentification spécifiés.

WindowsIdentity(IntPtr, String, WindowsAccountType)

Initialise une nouvelle instance de la classe WindowsIdentity pour l'utilisateur représenté par le jeton de compte Windows, le type d'authentification et le type de compte Windows spécifiés.

WindowsIdentity(IntPtr, String, WindowsAccountType, Boolean)

Initialise une nouvelle instance de la classe WindowsIdentity pour l'utilisateur représenté par le jeton de compte Windows, le type d'authentification et le type de compte Windows et l'état d'authentification spécifiés.

WindowsIdentity(SerializationInfo, StreamingContext)

Initialise une nouvelle instance de la classe WindowsIdentity pour l'utilisateur représenté par des informations dans un flux SerializationInfo.

WindowsIdentity(String)

Initialise une nouvelle instance de la classe WindowsIdentity pour l'utilisateur représenté par le nom d'utilisateur principal (UPN, User Principal Name) spécifié.

WindowsIdentity(String, String)

Initialise une nouvelle instance de la classe WindowsIdentity pour l'utilisateur représenté par le nom d'utilisateur principal (UPN) et le type d'authentification spécifiés.

WindowsIdentity(WindowsIdentity)

Initialise une nouvelle instance de la classe WindowsIdentity à l'aide de l'objet WindowsIdentity spécifié.

Champs

DefaultIssuer

Identifie le nom de l'émetteur ClaimsIdentity par défaut.

DefaultNameClaimType

Type de revendication de nom par défaut ; Name.

(Hérité de ClaimsIdentity)
DefaultRoleClaimType

Type de revendication de rôle par défaut ; Role.

(Hérité de ClaimsIdentity)

Propriétés

AccessToken

Obtient ce SafeAccessTokenHandle pour cette instance de WindowsIdentity.

Actor

Obtient ou définit l'identité de la partie appelante s'est vue accordée des droits de délégation.

(Hérité de ClaimsIdentity)
AuthenticationType

Obtient le type d'authentification utilisé pour identifier l'utilisateur.

BootstrapContext

Obtient ou définit le jeton qui a été utilisé pour créer cette identité basée sur les revendications.

(Hérité de ClaimsIdentity)
Claims

Obtient toutes les revendications pour l'utilisateur représenté par cette identité Windows.

Claims

Obtient les revendications associées à cette identité basée sur les revendications.

(Hérité de ClaimsIdentity)
CustomSerializationData

Contient les données supplémentaires fournies par un type dérivé. En règle générale, définie au moment de l’appel de WriteTo(BinaryWriter, Byte[]).

(Hérité de ClaimsIdentity)
DeviceClaims

Obtient les revendications qui ont la clé de propriété WindowsDeviceClaim.

Groups

Obtient les groupes auxquels l'utilisateur Windows actuel appartient.

ImpersonationLevel

Obtient le niveau d'emprunt d'identité pour l'utilisateur.

IsAnonymous

Obtient une valeur qui indique si le compte d'utilisateur est identifié en tant que compte anonyme par le système.

IsAuthenticated

Obtient une valeur indiquant si l'utilisateur a été authentifié par Windows.

IsGuest

Obtient une valeur indiquant si le compte d'utilisateur est identifié en tant que compte Guest par le système.

IsSystem

Obtient une valeur indiquant si le compte d'utilisateur est identifié en tant que compte System par le système.

Label

Obtient ou définit l'étiquette de cette identité basée sur les revendications.

(Hérité de ClaimsIdentity)
Name

Obtient le nom de connexion Windows de l'utilisateur.

NameClaimType

Obtient le type de revendication utilisé pour déterminer les revendications qui fournissent la valeur de la propriété Name de cette identité basée sur les revendications.

(Hérité de ClaimsIdentity)
Owner

Obtient l'identificateur de sécurité (SID) pour le propriétaire du jeton.

RoleClaimType

Obtient le type de revendication qui est interprétée comme un rôle .NET entre les revendications dans cette identité basée sur les revendications.

(Hérité de ClaimsIdentity)
Token

Obtient le jeton de compte Windows pour l'utilisateur.

User

Obtient l'identificateur de sécurité (SID) pour l'utilisateur.

UserClaims

Obtient les revendications qui ont la clé de propriété WindowsUserClaim.

Méthodes

AddClaim(Claim)

Ajoute une revendication unique à cette identité des revendications.

(Hérité de ClaimsIdentity)
AddClaims(IEnumerable<Claim>)

Ajoute une liste de revendications à cette identité de revendications.

(Hérité de ClaimsIdentity)
Clone()

Crée un objet qui est une copie de l'instance actuelle.

Clone()

Retourne une nouvelle ClaimsIdentity copiée à partir de cette identité basée sur les revendications.

(Hérité de ClaimsIdentity)
CreateClaim(BinaryReader)

Fournit un point d’extensibilité pour les types dérivés afin de créer un Claim personnalisé.

(Hérité de ClaimsIdentity)
Dispose()

Libère toutes les ressources utilisées par WindowsIdentity.

Dispose(Boolean)

Libère les ressources non managées utilisées par WindowsIdentity et libère éventuellement les ressources managées.

Equals(Object)

Détermine si l'objet spécifié est égal à l'objet actuel.

(Hérité de Object)
Finalize()

Libère les ressources détenues par l’instance actuelle.

FindAll(Predicate<Claim>)

Récupère toutes les revendications qui sont mises en correspondance par le prédicat spécifié.

(Hérité de ClaimsIdentity)
FindAll(String)

Récupère toutes les revendications qui ont le type de revendication spécifié.

(Hérité de ClaimsIdentity)
FindFirst(Predicate<Claim>)

Extrait la première revendication qui est mise en correspondance par le prédicat spécifié.

(Hérité de ClaimsIdentity)
FindFirst(String)

Extrait la première revendication avec le type de revendication spécifié.

(Hérité de ClaimsIdentity)
GetAnonymous()

Retourne un objet WindowsIdentity que vous pouvez utiliser comme valeur de sentinelle dans votre code pour représenter un utilisateur anonyme. La valeur de propriété ne représente pas l'identité anonyme prédéfinie utilisée par le système d'exploitation Windows.

GetCurrent()

Retourne un objet WindowsIdentity qui représente l'utilisateur Windows actuel.

GetCurrent(Boolean)

Retourne un objet WindowsIdentity représentant l'identité Windows pour le thread ou le processus, selon la valeur du paramètre ifImpersonating.

GetCurrent(TokenAccessLevels)

Retourne un objet WindowsIdentity qui représente l'utilisateur Windows actuel, en utilisant le niveau d'accès du jeton souhaité spécifié.

GetHashCode()

Fait office de fonction de hachage par défaut.

(Hérité de Object)
GetObjectData(SerializationInfo, StreamingContext)

Renseigne des SerializationInfo avec les données nécessaires à la sérialisation de l'objet ClaimsIdentity actuel.

(Hérité de ClaimsIdentity)
GetType()

Obtient le Type de l'instance actuelle.

(Hérité de Object)
HasClaim(Predicate<Claim>)

Détermine si cette identité des revendications a une revendication qui est mise en correspondance par l'attribut spécifié.

(Hérité de ClaimsIdentity)
HasClaim(String, String)

Détermine si cette identité des revendications a une revendication avec le type et la valeur de revendication spécifiques.

(Hérité de ClaimsIdentity)
Impersonate()

Emprunte l'identité de l'utilisateur représenté par l'objet WindowsIdentity.

Impersonate(IntPtr)

Emprunte l'identité de l'utilisateur représenté par le jeton utilisateur spécifié.

MemberwiseClone()

Crée une copie superficielle du Object actuel.

(Hérité de Object)
RemoveClaim(Claim)

Tente de supprimer une revendication dans l'identité basée sur les revendications.

(Hérité de ClaimsIdentity)
RunImpersonated(SafeAccessTokenHandle, Action)

Exécute l'action spécifiée en tant qu'identité Windows empruntée. Au lieu d'utiliser un appel de méthode emprunté et d'exécuter votre fonction dans WindowsImpersonationContext, vous pouvez utiliser RunImpersonated(SafeAccessTokenHandle, Action) et fournir votre fonction directement en tant que paramètre.

RunImpersonated<T>(SafeAccessTokenHandle, Func<T>)

Exécute la fonction spécifiée en tant qu'identité Windows empruntée. Au lieu d'utiliser un appel de méthode emprunté et d'exécuter votre fonction dans WindowsImpersonationContext, vous pouvez utiliser RunImpersonated(SafeAccessTokenHandle, Action) et fournir votre fonction directement en tant que paramètre.

RunImpersonatedAsync(SafeAccessTokenHandle, Func<Task>)

exécute l’action asynchrone spécifiée comme identité de Windows empruntée.

RunImpersonatedAsync<T>(SafeAccessTokenHandle, Func<Task<T>>)

exécute l’action asynchrone spécifiée comme identité de Windows empruntée.

ToString()

Retourne une chaîne qui représente l'objet actuel.

(Hérité de Object)
TryRemoveClaim(Claim)

Tente de supprimer une revendication dans l'identité basée sur les revendications.

(Hérité de ClaimsIdentity)
WriteTo(BinaryWriter)

Sérialise à l’aide d’un BinaryWriter.

(Hérité de ClaimsIdentity)
WriteTo(BinaryWriter, Byte[])

Sérialise à l’aide d’un BinaryWriter.

(Hérité de ClaimsIdentity)

Implémentations d’interfaces explicites

IDeserializationCallback.OnDeserialization(Object)

Implémente l’interface ISerializable et est rappelé par l’événement de désérialisation quand la désérialisation est terminée.

ISerializable.GetObjectData(SerializationInfo, StreamingContext)

Définit l'objet SerializationInfo avec les informations de contexte logiques nécessaires à la recréation d'une instance de ce contexte d'exécution.

S’applique à