Teilen über


SHA256Managed Klasse

Definition

Achtung

Derived cryptographic types are obsolete. Use the Create method on the base type instead.

Berechnet den SHA256-Hash für die Eingabedaten unter Verwendung der verwalteten Bibliothek.

public ref class SHA256Managed sealed : System::Security::Cryptography::SHA256
public ref class SHA256Managed : System::Security::Cryptography::SHA256
public sealed class SHA256Managed : System.Security.Cryptography.SHA256
[System.Obsolete("Derived cryptographic types are obsolete. Use the Create method on the base type instead.", DiagnosticId="SYSLIB0021", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
public sealed class SHA256Managed : System.Security.Cryptography.SHA256
public class SHA256Managed : System.Security.Cryptography.SHA256
[System.Runtime.InteropServices.ComVisible(true)]
public class SHA256Managed : System.Security.Cryptography.SHA256
type SHA256Managed = class
    inherit SHA256
[<System.Obsolete("Derived cryptographic types are obsolete. Use the Create method on the base type instead.", DiagnosticId="SYSLIB0021", UrlFormat="https://aka.ms/dotnet-warnings/{0}")>]
type SHA256Managed = class
    inherit SHA256
[<System.Runtime.InteropServices.ComVisible(true)>]
type SHA256Managed = class
    inherit SHA256
Public NotInheritable Class SHA256Managed
Inherits SHA256
Public Class SHA256Managed
Inherits SHA256
Vererbung
SHA256Managed
Attribute

Beispiele

Im folgenden Beispiel wird der SHA-256-Hash für alle Dateien in einem Verzeichnis berechnet.

using namespace System;
using namespace System::IO;
using namespace System::Security::Cryptography;

// Print the byte array in a readable format.
void PrintByteArray( array<Byte>^array )
{
   int i;
   for ( i = 0; i < array->Length; i++ )
   {
      Console::Write( String::Format( "{0:X2}", array[ i ] ) );
      if ( (i % 4) == 3 )
            Console::Write( " " );

   }
   Console::WriteLine();
}

int main()
{
   array<String^>^args = Environment::GetCommandLineArgs();
   if ( args->Length < 2 )
   {
      Console::WriteLine( "Usage: hashdir <directory>" );
      return 0;
   }

   try
   {

      // Create a DirectoryInfo object representing the specified directory.
      DirectoryInfo^ dir = gcnew DirectoryInfo( args[ 1 ] );

      // Get the FileInfo objects for every file in the directory.
      array<FileInfo^>^files = dir->GetFiles();

      // Initialize a SHA256 hash object.
      SHA256 ^ mySHA256 = SHA256Managed::Create();
      array<Byte>^hashValue;

      // Compute and print the hash values for each file in directory.
      System::Collections::IEnumerator^ myEnum = files->GetEnumerator();
      while ( myEnum->MoveNext() )
      {
         FileInfo^ fInfo = safe_cast<FileInfo^>(myEnum->Current);

         // Create a fileStream for the file.
         FileStream^ fileStream = fInfo->Open( FileMode::Open );

         // Compute the hash of the fileStream.
         hashValue = mySHA256->ComputeHash( fileStream );

         // Write the name of the file to the Console.
         Console::Write( "{0}: ", fInfo->Name );

         // Write the hash value to the Console.
         PrintByteArray( hashValue );

         // Close the file.
         fileStream->Close();
      }
      return 0;
   }
   catch ( DirectoryNotFoundException^ ) 
   {
      Console::WriteLine( "Error: The directory specified could not be found." );
   }
   catch ( IOException^ ) 
   {
      Console::WriteLine( "Error: A file in the directory could not be accessed." );
   }

}
using System;
using System.IO;
using System.Security.Cryptography;

public class HashDirectory
{
    public static void Main(string[] args)
    {
        if (args.Length < 1)
        {
            Console.WriteLine("No directory selected.");
            return;
        }

        string directory = args[0];
        if (Directory.Exists(directory))
        {
            // Create a DirectoryInfo object representing the specified directory.
            var dir = new DirectoryInfo(directory);
            // Get the FileInfo objects for every file in the directory.
            FileInfo[] files = dir.GetFiles();
            // Initialize a SHA256 hash object.
            using (SHA256 mySHA256 = SHA256.Create())
            {
                // Compute and print the hash values for each file in directory.
                foreach (FileInfo fInfo in files)
                {
                    using (FileStream fileStream = fInfo.Open(FileMode.Open))
                    {
                        try
                        {
                            // Create a fileStream for the file.
                            // Be sure it's positioned to the beginning of the stream.
                            fileStream.Position = 0;
                            // Compute the hash of the fileStream.
                            byte[] hashValue = mySHA256.ComputeHash(fileStream);
                            // Write the name and hash value of the file to the console.
                            Console.Write($"{fInfo.Name}: ");
                            PrintByteArray(hashValue);
                        }
                        catch (IOException e)
                        {
                            Console.WriteLine($"I/O Exception: {e.Message}");
                        }
                        catch (UnauthorizedAccessException e)
                        {
                            Console.WriteLine($"Access Exception: {e.Message}");
                        }
                    }
                }
            }
        }
        else
        {
            Console.WriteLine("The directory specified could not be found.");
        }
    }

    // Display the byte array in a readable format.
    public static void PrintByteArray(byte[] array)
    {
        for (int i = 0; i < array.Length; i++)
        {
            Console.Write($"{array[i]:X2}");
            if ((i % 4) == 3) Console.Write(" ");
        }
        Console.WriteLine();
    }
}
Imports System.IO
Imports System.Security.Cryptography

Public Module HashDirectory

    Public Sub Main(ByVal args() As String)
        If args.Length < 1 Then
            Console.WriteLine("No directory selected")
            Return
        End If

        Dim targetDirectory As String = args(0)
        If Directory.Exists(targetDirectory) Then
            ' Create a DirectoryInfo object representing the specified directory.
            Dim dir As New DirectoryInfo(targetDirectory)
            ' Get the FileInfo objects for every file in the directory.
            Dim files As FileInfo() = dir.GetFiles()
            ' Initialize a SHA256 hash object.
            Using mySHA256 As SHA256 = SHA256.Create()
                ' Compute and print the hash values for each file in directory.
                For Each fInfo  As FileInfo In files
                    Try
                        ' Create a fileStream for the file.
                        Dim fileStream = fInfo.Open(FileMode.Open)
                        ' Be sure it's positioned to the beginning of the stream.
                        fileStream.Position = 0
                        ' Compute the hash of the fileStream.
                        Dim hashValue() As Byte = mySHA256.ComputeHash(fileStream)
                        ' Write the name of the file to the Console.
                        Console.Write(fInfo.Name + ": ")
                        ' Write the hash value to the Console.
                        PrintByteArray(hashValue)
                        ' Close the file.
                        fileStream.Close()
                    Catch e As IOException
                        Console.WriteLine($"I/O Exception: {e.Message}")
                    Catch e As UnauthorizedAccessException 
                        Console.WriteLine($"Access Exception: {e.Message}")
                    End Try    
                Next 
            End Using
        Else
           Console.WriteLine("The directory specified could not be found.")
        End If
    End Sub

    ' Print the byte array in a readable format.
    Public Sub PrintByteArray(array() As Byte)
        For i As Integer = 0 To array.Length - 1
            Console.Write($"{array(i):X2}")
            If i Mod 4 = 3 Then
                Console.Write(" ")
            End If
        Next 
        Console.WriteLine()

    End Sub 
End Module

Hinweise

Der Hash wird als eindeutiger Wert mit fester Größe verwendet, der eine große Datenmenge darstellt. Hashes von zwei Datensätzen sollten nur übereinstimmen, wenn die entsprechenden Daten ebenfalls übereinstimmen. Kleine Änderungen an den Daten führen zu großen unvorhersehbaren Änderungen im Hash.

Die Hashgröße für den SHA256Managed Algorithmus beträgt 256 Bits.

Konstruktoren

SHA256Managed()
Veraltet.

Initialisiert eine neue Instanz der SHA256Managed-Klasse unter Verwendung der verwalteten Bibliothek.

Felder

HashSizeInBits
Veraltet.

Die vom SHA256-Algorithmus erzeugte Hashgröße in Bits.

(Geerbt von SHA256)
HashSizeInBytes
Veraltet.

Die vom SHA256-Algorithmus erzeugte Hashgröße in Bytes.

(Geerbt von SHA256)
HashSizeValue
Veraltet.

Stellt die Größe des berechneten Hashcodes in Bits dar.

(Geerbt von HashAlgorithm)
HashValue
Veraltet.

Stellt den Wert des errechneten Hashcodes dar.

(Geerbt von HashAlgorithm)
State
Veraltet.

Stellt den Zustand der Hashberechnung dar.

(Geerbt von HashAlgorithm)

Eigenschaften

CanReuseTransform
Veraltet.

Ruft einen Wert ab, der angibt, ob die aktuelle Transformation wiederverwendet werden kann.

(Geerbt von HashAlgorithm)
CanTransformMultipleBlocks
Veraltet.

Ruft beim Überschreiben in einer abgeleiteten Klasse einen Wert ab, der angibt, ob mehrere Blöcke transformiert werden können.

(Geerbt von HashAlgorithm)
Hash
Veraltet.

Ruft den Wert des berechneten Hashcodes ab.

(Geerbt von HashAlgorithm)
HashSize
Veraltet.

Ruft die Größe des berechneten Hashcodes in Bits ab.

(Geerbt von HashAlgorithm)
InputBlockSize
Veraltet.

Ruft beim Überschreiben in einer abgeleiteten Klasse die Eingabeblockgröße ab.

(Geerbt von HashAlgorithm)
OutputBlockSize
Veraltet.

Ruft beim Überschreiben in einer abgeleiteten Klasse die Ausgabeblockgröße ab.

(Geerbt von HashAlgorithm)

Methoden

Clear()
Veraltet.

Gibt alle von der HashAlgorithm-Klasse verwendeten Ressourcen frei.

(Geerbt von HashAlgorithm)
ComputeHash(Byte[])
Veraltet.

Errechnet den Hashwert für das angegebene Bytearray.

(Geerbt von HashAlgorithm)
ComputeHash(Byte[], Int32, Int32)
Veraltet.

Berechnet den Hashwert für den angegebenen Bereich des angegebenen Bytearrays.

(Geerbt von HashAlgorithm)
ComputeHash(Stream)
Veraltet.

Berechnet den Hashwert für das angegebene Stream-Objekt.

(Geerbt von HashAlgorithm)
ComputeHashAsync(Stream, CancellationToken)
Veraltet.

Berechnet den Hashwert für das angegebene Stream-Objekt asynchron.

(Geerbt von HashAlgorithm)
Dispose()
Veraltet.

Gibt alle von der aktuellen Instanz der HashAlgorithm-Klasse verwendeten Ressourcen frei.

(Geerbt von HashAlgorithm)
Dispose(Boolean)
Veraltet.

Gibt die vom SHA256Managed-Objekt verwendeten nicht verwalteten Ressourcen und optional die verwalteten Ressourcen frei.

Dispose(Boolean)
Veraltet.

Gibt die von HashAlgorithm verwendeten nicht verwalteten Ressourcen und optional die verwalteten Ressourcen frei.

(Geerbt von HashAlgorithm)
Equals(Object)
Veraltet.

Bestimmt, ob das angegebene Objekt gleich dem aktuellen Objekt ist.

(Geerbt von Object)
GetHashCode()
Veraltet.

Fungiert als Standardhashfunktion.

(Geerbt von Object)
GetType()
Veraltet.

Ruft den Type der aktuellen Instanz ab.

(Geerbt von Object)
HashCore(Byte[], Int32, Int32)
Veraltet.

Leitet beim Überschreiben in einer abgeleiteten Klasse die in das Objekt geschriebenen Daten zum Errechnen des Hashs an den SHA256-Hashalgorithmus weiter.

HashCore(Byte[], Int32, Int32)
Veraltet.

Leitet beim Überschreiben in einer abgeleiteten Klasse die in das Objekt geschriebenen Daten zum Errechnen des Hashs an den Hashalgorithmus weiter.

(Geerbt von HashAlgorithm)
HashCore(ReadOnlySpan<Byte>)
Veraltet.

Leitet die in das Objekt geschriebenen Daten zum Berechnen des Hashs in den Hashalgorithmus weiter.

(Geerbt von HashAlgorithm)
HashFinal()
Veraltet.

Schließt beim Überschreiben in einer abgeleiteten Klasse die Berechnung des Hashs ab, nachdem die letzten Daten vom Kryptografiestreamobjekt verarbeitet wurden.

HashFinal()
Veraltet.

Schließt beim Überschreiben in einer abgeleiteten Klasse die Berechnung des Hashs ab, nachdem die letzten Daten vom kryptografischen Hashalgorithmus verarbeitet wurden.

(Geerbt von HashAlgorithm)
Initialize()
Veraltet.

Initialisiert eine Instanz von SHA256Managed.

MemberwiseClone()
Veraltet.

Erstellt eine flache Kopie des aktuellen Object.

(Geerbt von Object)
ToString()
Veraltet.

Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt.

(Geerbt von Object)
TransformBlock(Byte[], Int32, Int32, Byte[], Int32)
Veraltet.

Errechnet den Hashwert für den angegebenen Bereich des Eingabebytearrays und kopiert den angegebenen Bereich des Eingabebytearrays in den angegebenen Bereich des Ausgabebytearrays.

(Geerbt von HashAlgorithm)
TransformFinalBlock(Byte[], Int32, Int32)
Veraltet.

Berechnet den Hashwert für den angegebenen Bereich des angegebenen Bytearrays.

(Geerbt von HashAlgorithm)
TryComputeHash(ReadOnlySpan<Byte>, Span<Byte>, Int32)
Veraltet.

Versucht, den Hashwert für das angegebene Bytearray zu berechnen.

(Geerbt von HashAlgorithm)
TryHashFinal(Span<Byte>, Int32)
Veraltet.

Versucht, die Hashberechnung abzuschließen, nachdem die letzten Daten vom Hashalgorithmus verarbeitet wurden.

(Geerbt von HashAlgorithm)

Explizite Schnittstellenimplementierungen

IDisposable.Dispose()
Veraltet.

Gibt die von HashAlgorithm verwendeten nicht verwalteten Ressourcen und optional die verwalteten Ressourcen frei.

(Geerbt von HashAlgorithm)

Gilt für:

Weitere Informationen