# AsymmetricAlgorithm.KeySizeAsymmetricAlgorithm.KeySizeAsymmetricAlgorithm.KeySizeAsymmetricAlgorithm.KeySize Property

## Définition

Obtient ou définit la taille, en bits, du modulo de clé utilisé par l'algorithme asymétrique.Gets or sets the size, in bits, of the key modulus used by the asymmetric algorithm.

``````public:
virtual property int KeySize { int get(); void set(int value); };``````
``public virtual int KeySize { get; set; }``
``member this.KeySize : int with get, set``
``Public Overridable Property KeySize As Integer``

#### Valeur de propriété

Taille, en bits, du modulo de clé utilisé par l'algorithme asymétrique.The size, in bits, of the key modulus used by the asymmetric algorithm.

#### Exceptions

La taille du modulo de la clé n’est pas valide.The key modulus size is invalid.

## Exemples

L’exemple de code suivant montre comment substituer la KeySize propriété pour vérifier qu’il se trouve dans la plage identifiée dans local `keySizes` variable membre.The following code example demonstrates how to override the KeySize property to verify that it falls within the range identified in the local `keySizes` member variable. Cet exemple de code fait partie d’un exemple plus complet fourni pour la AsymmetricAlgorithm classe.This code example is part of a larger example provided for the AsymmetricAlgorithm class.

``````public:
property int KeySize
{
virtual int get() override
{
return KeySizeValue;
}

virtual void set(int value) override
{
for (int i = 0; i < customValidKeySizes->Length; i++)
{
if (customValidKeySizes[i]->SkipSize == 0)
{
if (customValidKeySizes[i]->MinSize == value)
{
KeySizeValue = value;
return;
}
}
else
{
for (int j = customValidKeySizes[i]->MinSize;
j <= customValidKeySizes[i]->MaxSize;
j += customValidKeySizes[i]->SkipSize)
{
if (j == value)
{
KeySizeValue = value;
return;
}
}
}
}

// If the key does not fall within the range identified
// in the keySizes member variable, throw an exception.
throw gcnew CryptographicException("Invalid key size.");
}
}
``````
``````public override int KeySize
{
get { return KeySizeValue; }
set
{
for (int i=0; i < keySizes.Length; i++)
{
if (keySizes[i].SkipSize == 0)
{
if (keySizes[i].MinSize == value)
{
KeySizeValue = value;
return;
}
}
else
{
for (int j = keySizes[i].MinSize;
j <= keySizes[i].MaxSize;
j += keySizes[i].SkipSize)
{
if (j == value)
{
KeySizeValue = value;
return;
}
}
}
}

// If the key does not fall within the range identified
// in the keySizes member variable, throw an exception.
throw new CryptographicException("Invalid key size.");
}
}
``````
``````Public Overrides Property KeySize() As Integer
Get
Return KeySizeValue
End Get
Set(ByVal Value As Integer)
For i As Int16 = 0 To keySizes.Length - 1 Step i
If (keySizes(i).SkipSize.Equals(0)) Then
If (keySizes(i).MinSize.Equals(Value)) Then
KeySizeValue = Value
Return
End If
Else
For j As Integer = keySizes(i).MinSize _
To keySizes(i).MaxSize _
Step keySizes(i).SkipSize
If (j.Equals(Value)) Then
KeySizeValue = Value
Return
End If
Next
End If
Next
' If the key does not fall within the range identified
' in the keySizes member variable, throw an exception.
Throw New CryptographicException("Invalid key size.")
End Set
End Property
``````

## Remarques

Les tailles de clé valides sont spécifiées par l’implémentation particulière de l’algorithme asymétrique et sont répertoriées dans le LegalKeySizes propriété.The valid key sizes are specified by the particular implementation of the asymmetric algorithm and are listed in the LegalKeySizes property.