C# Funktion zum Übersetzen von Binärcode

Question

Im Moment versuche ich ein C# -Programm zu schreiben, um 8 Base Binary in Text zu übersetzen.

Aber ich denke, ich nicht mit C# erfahren genug bin wirklich, damit es funktioniert.

Ich denke, der Code, den ich mir ausgedacht habe, sollte von einem logischen Point-of-View etwas tun, was ich will, aber die Syntax tut es nicht richtig, da ich es nicht besser weiß.

Dies ist, was ich bisher:

using System; 
using System.Linq; 
using System.Text; 

class binaryTranslate 
{ 
    public int convertBin(string CodeInput) 
    { 
     int [] code = CodeInput.ToArray(); 
     int CodeCount = code.ToString().Length; 
     int EightBaseSegAmount = CodeCount/8; 
     int ByteCapacity = 8; 
     StringBuilder translated = new StringBuilder(); 

     for (var i = 1; i < EightBaseSegAmount + 1; i++) 
     { 
      StringBuilder Byte = new StringBuilder(ByteCapacity); 
      int ByteStart = (i * 8) - 8; 
      int ByteEnd = (i * 8) - 1; 
      int ByteIncrement = 1; 

       for (var j = ByteStart ; j < ByteEnd + 1; j++) 
       { 
        Byte.Append(code[j]); 
       } 

      for (var k = 0; k > 7; k++) 
      { 
       int BitValue = 128; 


       if (Byte[k] == 1) 
       { 
        if (k > 0) 
        { 
         int Squared = Math.Pow(2, k); 
         ByteIncrement += BitValue/Squared; 
        } 
        else 
        { 
         ByteIncrement += BitValue; 
        } 
       } 

      } 
      char toSymbol = Convert.ToChar(ByteIncrement); 
      translated.Append(toSymbol); 
     } 

     return translated; 
    } 

    public static int Main() 
    { 
     convertBin("010010000110000101101100011011000110111100100001"); 
    } 
} 

Answer 1

Wenn Sie wirklich, wie dieses

namespace binaryTranslate 
{ 
    class Program 
    { 
     static void Main(string[] args) 
     { 

      //convertBin("01001000 01100001 01101100 01101100 01101111 00100001"); 
      string results = BinaryTranslate.convertBin(new byte[] { 0x44, 0x61, 0x6c, 0x6c, 0x6f, 0x21 }); 
     } 
    } 
    public class BinaryTranslate 
    { 
     public static string convertBin(byte[] CodeInput) 
     { 
      return string.Join("", CodeInput.Select(x => x.ToString("X2"))); 

     } 
    } 
} 

Answer 2

sollte den Trick dieser Umwandlung werden sehen Sie den Code in einen String sollte.

public static string FromBinary(string binary) 
{ 
    int WordLength = 8; 

    binary = binary.Replace(' ', ''); 
    while(binary.Length % WordLength != 0) 
     binary += "0"; 

    string output = String.Empty; 
    string word = String.Empty; 
    int offset = 0; 

    while(offset < binary.Length) 
    { 
     int tmp = 0; 
     word = binary.Substring(offset, 8); 
     for(int i=0; i<(WordLength - 1); i++) 
      if(word[i] == '1') 
       tmp += (int) Math.Pow(2, i); 

     output += Convert.ToChar(tmp); 
     offset += WordLength; 
    } 

    return output; 
} 

Answer 3

Zunächst wird Ihr Code nicht kompilieren. Hier sind die Fehler/Fehler.

• Die erste ist, in der ersten Zeile Ihrer Funktion, können Sie die Eingabezeichenfolge in ein Array konvertieren String.ToArray() verwenden, die eine char[] aber Ihr Versuch gibt es eine Variable (Code) int[] eingegeben zuweisen. Sie können dies lösen, indem Sie die int[] durch char[] oder var ersetzen.
• Die zweite ist, innerhalb der zweiten For-Schleife (k = 0; k > 7), verwenden Sie Math.Pow() und zuweisen Sie den Rückgabewert an eine int Variable (Squared). Aber Math.Pow kehrt doppelt zurück. Sie können dies lösen, indem Sie den Rückgabewert Math.Pow an int übergeben. Mögen; int Squared = (int)Math.Pow(2, k);
• Das letzte Ding ist nicht leicht lösbar wie die ersten beiden, weil Ihr Code nicht genau richtig ist. Sie versuchen, etwas mit der Bezeichnung translated zurückzugeben, das eine Variable vom Typ StringBuilder ist. Ihre Funktion ist jedoch so definiert, dass sie eine int zurückgibt.

Nun waren diese Fehler kompilieren. Es gibt eine Reihe von logischen und Entscheidungsfehlern. Dein Algorithmus ist auch nicht sehr korrekt.

Hier ist ein Beispielcode, den Sie verwenden/untersuchen können. Ich würde dir gerne weiterhelfen, warum dein Code falsch war, was deine Designfehler waren, wenn du willst.

class binaryTranslate 
{ 
    public enum IncompleteSegmentBehavior 
    { 
     Skip = 0, 
     ZerosToStart = 1, 
     ZerosToEnd = 2 
    } 

    private byte ConvertBinstrToByte(string sequence) 
    { 
     if (string.IsNullOrEmpty(sequence)) 
      return 0; // Throw? 

     if (sequence.Length != sizeof(byte) * 8) 
      return 0; // Throw? 

     const char zero = '0'; 
     const char one = '1'; 

     byte value = 0; 
     for (int i = 0; i < sequence.Length; i++) 
     { 
      if (sequence[i] != zero && sequence[i] != one) 
       return 0; // Throw 

      value |= (byte)((sequence[i] - zero) << (7 - i)); 
     } 

     return value; 
    } 

    private string HandleIncompleteSegment(string segment, int segmentSize, IncompleteSegmentBehavior behavior) 
    { 
     string result = null; 

     var zeroAppender = new StringBuilder(); 
     for (int i = 0; i < segmentSize - segment.Length; i++) 
      zeroAppender.Append('0'); 

     var zeros = zeroAppender.ToString(); 

     switch (behavior) 
     { 
      case IncompleteSegmentBehavior.Skip: 
       break; 
      case IncompleteSegmentBehavior.ZerosToStart: 
       result = zeros + result; 
       break; 
      case IncompleteSegmentBehavior.ZerosToEnd: 
       result = result + zeros; 
       break; 
      default: 
       break; 
     } 

     return result; 
    } 

    public byte[] ConvertBinstrToBytes(string binarySequence, IncompleteSegmentBehavior behavior = IncompleteSegmentBehavior.Skip) 
    { 
     var segmentSize = sizeof(byte) * 8; 

     var sequenceLength = binarySequence.Length; 

     var numberOfBytes = (int)Math.Ceiling((double)sequenceLength/segmentSize); 
     var bytes = new byte[numberOfBytes]; 

     for (int i = 0; i < numberOfBytes; i++) 
     { 
      var charactersLeft = sequenceLength - i * segmentSize; 
      var segmentLength = (charactersLeft < segmentSize ? charactersLeft : segmentSize); 
      var segment = binarySequence.Substring(i * segmentSize, segmentLength); 

      if (charactersLeft < segmentSize) 
      { 
       segment = HandleIncompleteSegment(segment, segmentSize, behavior); 
       if (segment == null) 
        continue; 
      } 

      bytes[i] = ConvertBinstrToByte(segment); 
     } 

     return bytes; 
    } 
} 

Dieser Code besteht diese Behauptungen.

var bytes = new binaryTranslate() 
    .ConvertBinstrToBytes("00000000"); 

Assert.Equal(bytes.Length, 1); 
Assert.Equal(bytes[0], 0b00000000); 

bytes = new binaryTranslate() 
    .ConvertBinstrToBytes("10000000"); 

Assert.Equal(bytes.Length, 1); 
Assert.Equal(bytes[0], 0b10000000); 

bytes = new binaryTranslate() 
    .ConvertBinstrToBytes("11111111"); 

Assert.Equal(bytes.Length, 1); 
Assert.Equal(bytes[0], 0b11111111); 

bytes = new binaryTranslate() 
    .ConvertBinstrToBytes("00000001"); 

Assert.Equal(bytes.Length, 1); 
Assert.Equal(bytes[0], 0b00000001); 

bytes = new binaryTranslate() 
    .ConvertBinstrToBytes("1100110000110011"); 

Assert.Equal(bytes.Length, 2); 
Assert.Equal(bytes[0], 0b11001100); 
Assert.Equal(bytes[1], 0b00110011);