Redigeeri

Jagamisviis:

AsymmetricAlgorithm.KeySize Property

  • Reference

Definition

Namespace:
System.Security.Cryptography
Assembly:
System.Security.Cryptography.Primitives.dll
Assembly:
System.Security.Cryptography.dll
Assembly:
mscorlib.dll
Assembly:
netstandard.dll
Source:
AsymmetricAlgorithm.cs
Source:
AsymmetricAlgorithm.cs
Source:
AsymmetricAlgorithm.cs

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

Property Value

Int32

The size, in bits, of the key modulus used by the asymmetric algorithm.

Exceptions

CryptographicException

The key modulus size is invalid.

Examples

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. 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

Remarks

The valid key sizes are specified by the particular implementation of the asymmetric algorithm and are listed in the LegalKeySizes property.

Applies to

See also