F #: Konvertieren einer Zeichenfolge in ein Array von Bytes

Question

Ich schreibe ein einfaches RC4-Verschlüsselung/Entschlüsselungsprogramm als ein erstes Projekt. Ich bleibe dran, den gegebenen String in ein Array von Bytes zu konvertieren, die dann vom Core-Algorithmus manipuliert werden können. Wie konvertiert man einen String in ein Array von Bytes in funktionalem f #?

//From another thread 
let private replace find (repl : string) (str : string) = str.Replace(find, repl) 

//let private algorithm bytes = blah blah blah 

let Encrypt (decrypted : string) = 
    decrypted.Chars 
    |> Array.map(fun c -> byte.Parse(c)) // This line is clearly not working 
    // |> algorithm 
    |> BitConverter.ToString 
    |> replace "-" "" 

FYI in C# sieht es so aus:

public static string Encrypt(string decrypted) 
    { 
     byte[] bytes = new byte[decrypted.Length]; 

     for (int i = 0; i < decrypted.Length; ++i) 
      bytes[i] = (byte)decrypted[i]; 

     Algorithm(ref bytes); 

     return BitConverter.ToString(bytes).Replace("-", "").ToLower(); 
    } 

Answer 1

Obwohl Sie Ihre eigene Funktion schreiben, könnte die Arbeit zu tun, seine besten mit den integrierten .NET Methoden bleiben:

String Bytes:

System.Text.Encoding.ASCII.GetBytes("hello world!") 

Bytes zu string:

System.Text.Encoding.ASCII.GetString([|104uy; 101uy; 108uy; 108uy; 
      111uy; 32uy; 119uy; 111uy; 114uy; 108uy; 100uy; 33uy|]) 

Answer 2

Sie eine direkte Übersetzung

let Encrypt(decrypted : string) = 
    let bytes = Array.init decrypted.Length (fun i -> byte decrypted.[i]) 
    Algorithm(ref bytes) 
    BitConverter.ToString(bytes).Replace("-", "").ToLower() 

Answer 3

Per Gradbot Antrag tun könnte, sieht der endgültige Code wie:

1) I

2 bis Byte nicht die Würfe mögen) Die Hauptalgorithmusfunktion sieht sehr unfunktionell aus

Konstruktive Kritik ist willkommen.

Rc4.fs

#light 

open System 
open MiscUtils 
open StringUtils 

let private key = "Mykey"B 
let private byteMask = 0xff 
let private byteMax = byteMask 

let private algorithm (bytes : byte[]) = 
    let mutable j = 0 
    let mutable i = 0 
    let mutable s = [| for c in 0 .. byteMax -> (byte) c |] 

    for i in 0 .. byteMax do 
     j <- (j + (int) (s.[i] + key.[i % key.GetLength(0)])) &&& byteMask 
     Swap (&s.[i]) (&s.[j]) 

    i <- 0 
    j <- 0 
    for x in 0 .. bytes.Length - 1 do 
     i <- (i + 1) &&& byteMask 
     j <- (j + (int) s.[i]) &&& byteMask 
     Swap (&s.[i]) (&s.[j]) 
     let mutable t = (int)(s.[i] + s.[j]) &&& byteMask 
     bytes.[x] <- bytes.[x] ^^^ s.[t] 

    bytes 

let Encrypt (decrypted : string) = 
    Text.Encoding.ASCII.GetBytes decrypted 
    |> algorithm 
    |> BitConverter.ToString 
    |> ToLower 
    |> Replace "-" "" 

let Decrypt (encrypted : string) = 
    [| for i in 0 .. 2 .. encrypted.Length - 1 -> Convert.ToByte(encrypted.Substring(i, 2), 16) |] 
    |> algorithm 
    |> System.Text.Encoding.ASCII.GetString 

StringUtils.Fs

#light 

let Replace find (repl : string) (str : string) = str.Replace(find, repl) 
let ToLower (str : string) = str.ToLower() 

MiscUtils.fs

#light 

let Swap (left : 'a byref) (right : 'a byref) = 
    let temp = left 
    left <- right 
    right <- temp