//string strss = ""; void StartHandleData(string[] msg) { if (msg[0] == null) { return; } if (msg.Length == 6 || msg.Length == 7) { if (zoomId != "" && zoomId != "0") { NormalData(msg); } } else if (msg.Length == 8) { if (msg[0] == "FF" && msg[1] == "0C" && msg[2] == "02") { string zid = Hexadecimal.ConvertBase(msg[3], 16, 10); if (zid != "0" && !string.IsNullOrWhiteSpace(zid)) { if (int.Parse(oldId) < zCount * dNo && int.Parse(oldId) >= int.Parse(zid)) { ExceptionData(); } } zoomId = Hexadecimal.ConvertBase(msg[3], 16, 10); } } }
public void Write_UInt64_Throws_When_Buffer_Is_Too_Small() { var chars = new char[1]; var ex = Assert.Throws <ArgumentException>(() => Hexadecimal.Write(0UL, chars)); Assert.Equal("output", ex.ParamName); }
private static ArrayLease <char> TranslateBytesToHex(ArraySegment <byte> bytes, out int charCount) { byte[] buffer = bytes.Array; int offset = bytes.Offset; charCount = bytes.Count * 2; var lease = ArrayPool <char> .Shared.Lease(charCount); try { var chars = lease.Array; int j = 0; char left, right; for (int i = 0; i < bytes.Count; i++) { byte b = buffer[offset + i]; Hexadecimal.FromByte(b, out left, out right); chars[j] = left; chars[j + 1] = right; j += 2; } Debug.Assert(j == charCount); } catch { lease.Dispose(); throw; } return(lease); }
public void Write_Throws_When_Buffer_Is_Too_Small(int byteCount, int charCount, char?separator) { var chars = new char[charCount]; var ex = Assert.Throws <ArgumentException>(() => Hexadecimal.Write(new byte[byteCount], chars, separator)); Assert.Equal("output", ex.ParamName); }
public void Write_UInt64(ulong input, LetterCase letterCase, string expected) { var chars = new char[16]; Hexadecimal.Write(input, chars, letterCase); Assert.Equal(expected, new string(chars)); }
public static void DecodeAndValidateUserInputTest(string seed, string pgpSeed) { var decodedSeed = WalletSeed.DecodeAndValidateUserInput(pgpSeed, PgpWordList); var decodedSeedHex = Hexadecimal.Decode(seed); Assert.Equal(decodedSeedHex, decodedSeed); }
public void Write_Byte(byte input, LetterCase letterCase, string expected) { var chars = new char[2]; Hexadecimal.Write(input, chars, letterCase); Assert.Equal(expected, new string(chars)); }
private async Task ManageStakePoolsActionAsync() { var prevConfiguredStakepoolCount = ConfiguredStakePools.Count; // Open dialog that downloads stakepool listing and lets user enter their api key. var shell = (ShellViewModel)ViewModelLocator.ShellViewModel; var dialog = new ManageStakePoolsDialogViewModel(shell); shell.ShowDialog(dialog); await dialog.NotifyCompletionSource.Task; // Wait until dialog is hidden await App.Current.Dispatcher.InvokeAsync(() => { foreach (var configuredPool in dialog.ConfiguredPools) { var poolInfo = configuredPool.Item1; var poolUserConfig = configuredPool.Item2; if (!ConfiguredStakePools.OfType <StakePoolSelection>().Where(p => p.PoolInfo.Uri.Host == poolInfo.Uri.Host).Any()) { var stakePoolSelection = new StakePoolSelection(poolInfo, poolUserConfig.ApiKey, Hexadecimal.Decode(poolUserConfig.MultisigVoteScript)); ConfiguredStakePools.Add(stakePoolSelection); RaisePropertyChanged(nameof(VotePreferencesVisibility)); SelectedStakePool = stakePoolSelection; } } }); if (prevConfiguredStakepoolCount != ConfiguredStakePools.Count) { await UpdateStakepoolVotePreferences(); } }
private async Task<byte[]> GetData() { switch (DecodeContentType) { case DecodeContentTypeEnum.Hexa: Hexadecimal = Compact(Hexadecimal).Replace("-", "").Trim(); int len = Hexadecimal.Length / 2; var tmp = new byte[len]; for (int i = 0; i < len; i++) { tmp[i] = Convert.ToByte(Hexadecimal.Substring(i * 2, 2), 16); } return tmp; case DecodeContentTypeEnum.Base64: return Convert.FromBase64String(Compact(Base64)); case DecodeContentTypeEnum.File: var ms = new System.IO.MemoryStream(); await File.Data.CopyToAsync(ms); return ms.ToArray(); default: throw new ArgumentOutOfRangeException($"Decode content type not implemented {DecodeContentType}"); } }
public static Numeric_Base Decode(char choise) { Numeric_Base numeric_Base; switch (choise) { case 'b': numeric_Base = new Binary(); break; case 'o': numeric_Base = new Octal(); break; case 'd': numeric_Base = new Decimal(); break; case 'x': numeric_Base = new Hexadecimal(); break; default: numeric_Base = null; break; } return(numeric_Base); }
private void UpdateColor(string answerValue) { if (answerValue != string.Empty) { _colorDialog.Color = Hexadecimal.FromString(answerValue).ToColor(); } }
private static string FormatHexadecimal(ReadOnlyMemory <byte> bytes) { var charLength = bytes.Length * 2; var chars = charLength <= 64 ? stackalloc char[charLength] : new char[charLength]; Hexadecimal.Write(bytes.Span, chars); return(new string(chars)); }
private void SendHex(TextBox textBox) { var bytes = Hexadecimal.Parse(textBox.Text); textBox.Text = Hexadecimal.ToString(bytes); buffer.Output(bytes, false); ior.Run(() => iom.Write(bytes)); }
public void TryParse_With_Valid_Input(string input, char?separator, byte[] expected) { var actual = new byte[expected.Length]; var succeeded = Hexadecimal.TryParse(input, actual, separator); Assert.True(succeeded); Assert.Equal(expected, actual); }
public static void ValidDecodings(string hexEncoding, string pgpWordListEncoding) { var words = pgpWordListEncoding.Split(); var expectedBytes = Hexadecimal.Decode(hexEncoding); var decodedBytes = PgpWordList.Decode(words); Assert.Equal(expectedBytes, decodedBytes); }
public void Write(byte[] input, LetterCase @case, char?separator, string expected) { var chars = new char[expected.Length]; Hexadecimal.Write(input, chars, separator, @case); var actual = new string(chars); Assert.Equal(expected, actual); }
public void ToHexChars_Regularly_ShouldReturnExpectedOutput(string text, string hexString) { var bytes = System.Text.Encoding.UTF8.GetBytes(text); Span <byte> outputChars = stackalloc byte[hexString.Length]; Hexadecimal.ToHexChars(bytes, outputChars); var outputString = System.Text.Encoding.UTF8.GetString(outputChars); Assert.Equal(hexString, outputString); }
public void FromHexChars_Regularly_ShouldReturnExpectedOutput(string text, string hexString) { var chars = System.Text.Encoding.UTF8.GetBytes(hexString); Span <byte> outputBytes = stackalloc byte[text.Length]; Hexadecimal.FromHexChars(chars, outputBytes); var originalString = System.Text.Encoding.UTF8.GetString(outputBytes); Assert.Equal(text, originalString); }
public static void PositiveHexTests(string decodedAsHexString, string encoded) { var decoded = Hexadecimal.Decode(decodedAsHexString); var encodeResult = Base58.Encode(decoded); Assert.Equal(encoded, encodeResult); var decodeResult = Base58.Decode(encoded); Assert.Equal(decoded, decodeResult); }
public void FromHexChars_AfterToHexChars_ShouldReturnOriginalInput(string text, string hexString) { var bytes = System.Text.Encoding.UTF8.GetBytes(text); Span <byte> outputChars = stackalloc byte[hexString.Length]; Hexadecimal.ToHexChars(bytes, outputChars); Span <byte> decodedBytes = stackalloc byte[bytes.Length]; Hexadecimal.FromHexChars(outputChars, decodedBytes); var originalString = System.Text.Encoding.UTF8.GetString(decodedBytes); Assert.Equal(text, originalString); }
public void Write_Succeeds(string stationId6, string muxs, string routerDataEndpoint, string expected) { var stationEui = stationId6.Contains(':', StringComparison.Ordinal) ? Id6.TryParse(stationId6, out var id6) ? new StationEui(id6) : throw new JsonException() : Hexadecimal.TryParse(stationId6, out ulong hhd, '-') ? new StationEui(hhd) : throw new JsonException(); var computed = Json.Stringify(w => LnsDiscovery.WriteResponse(w, stationEui, muxs, new Uri(routerDataEndpoint))); Assert.Equal(expected, computed); }
public static void DecodeIsCaseInsensitive(string hexEncoding, string pgpWordListEncoding) { var expectedBytes = Hexadecimal.Decode(hexEncoding); var upperCaseWords = pgpWordListEncoding.ToUpper().Split(); var decodedUpperCase = PgpWordList.Decode(upperCaseWords); Assert.Equal(expectedBytes, decodedUpperCase); var lowerCaseWords = pgpWordListEncoding.ToLower().Split(); var decodedLowerCase = PgpWordList.Decode(lowerCaseWords); Assert.Equal(expectedBytes, decodedLowerCase); }
public OutputScript BuildOutputScript() { switch (OutputType) { case Kind.Address: var address = Address.Decode(Destination); return(address.BuildScript()); case Kind.Script: return(new OutputScript.Unrecognized(Hexadecimal.Decode(Destination))); default: throw new Exception($"Unknown pending output kind {OutputType}"); } }
private void DataBind() { this.cmbColors.Items.Clear(); foreach (int argb in this.colors) { Color c = Color.FromArgb(argb); this.cmbColors.Items.Add("#" + Hexadecimal.ToString(c.R, 2) + Hexadecimal.ToString(c.G, 2) + Hexadecimal.ToString(c.B, 2)); } if (this.currentColor != null && this.currentColor.HasValue) { this.cmbColors.Text = "#" + Hexadecimal.ToString(this.currentColor.Value.R, 2) + Hexadecimal.ToString(this.currentColor.Value.G, 2) + Hexadecimal.ToString(this.currentColor.Value.B, 2); } else { this.cmbColors.Text = ""; } }
public static string ToString(ref Blake256HashBuffer buffer) { var reverseCopy = new byte[Length]; unsafe { fixed(byte *p = buffer._data) { for (int i = 0, j = Length - 1; i < Length; ++i, --j) { reverseCopy[i] = p[j]; } } } return(Hexadecimal.Encode(reverseCopy)); }
private static byte[] DecodeUserInput(string userInput, PgpWordList pgpWordList) { byte[] seed; if (Hexadecimal.TryDecode(userInput, out seed)) { return(seed); } var splitInput = userInput.Split(new char[0], StringSplitOptions.RemoveEmptyEntries); if (splitInput.Length == 1) { // Hex decoding failed, but it's not a multi-word mneumonic either. // Assume the user intended hex. throw new HexadecimalEncodingException(); } return(pgpWordList.Decode(splitInput)); }
/// <summary> /// 正常数据 /// </summary> void NormalData(string[] msg) { //if (zoomId == oldId) // return; string statusNo = Hexadecimal.ConvertBase(msg[0], 16, 10); if (string.IsNullOrWhiteSpace(statusNo)) { return; } string status = Enum.GetName(typeof(H3CMsgType), int.Parse(statusNo)); if (string.IsNullOrWhiteSpace(status)) { return; } oldId = zoomId; string dianya = Hexadecimal.ConvertBase(msg[1] + msg[2], 16, 10); StringHelper.RepairZero(dianya, 4); string dianliu = (double.Parse(Hexadecimal.ConvertBase(msg[3], 16, 10)) / 10).ToString("#0.0"); if (dianliu == "0.0" && dianya == "0" && status == "正常") { //checkTime = DateTime.Now; // return; status = "异常"; statusNo = "7"; } H3CPowerGridData data = new H3CPowerGridData() { DeviceIp = powerIp, EventType = (H3CMsgType)Enum.Parse(typeof(H3CMsgType), statusNo), PowerFlow = dianliu, PowerGridState = int.Parse(statusNo), Voltage = dianya, ZoomId = int.Parse(zoomId) }; SendZoomData(data); }
public static ArrayLease <byte> DecryptHexToBytes(string ciphertext, ArraySegment <byte> key, out int count) { // Throw if the string isn't divisible by 2, since bytes are 2 hex digits if ((ciphertext.Length & 1) != 0) // ciphertext.Length % 2 != 0 { // TODO: Strings.resx if it's worth it (see notes above) throw new ArgumentException( message: "The ciphertext needs to be hex-encoded and have a length divisible by 2.", paramName: nameof(ciphertext)); } int bufferLength = ciphertext.Length / 2; var rented = ArrayPool <byte> .Shared.Rent(bufferLength); try { Debug.Assert(bufferLength <= rented.Length); // Do the translation via Hexadecimal.ToByte int i = 0, j = 0; while (i < bufferLength) { rented[i] = Hexadecimal.ToByte(ciphertext[j], ciphertext[j + 1]); i += 1; j += 2; } Debug.Assert(i == bufferLength && j == i * 2); // Now call DecryptBytes with the key/encrypted buffer var encryptedBytes = new ArraySegment <byte>(rented, 0, bufferLength); return(DecryptBytes(encryptedBytes, key, out count)); } finally { ArrayPool <byte> .Shared.Return(rented); } }
private static ExitCode RunDecodeOptionsAndReturnExitCode(DecodeOptions decodeOptions) { string decodedString = null; string errorMsg = null; switch (decodeOptions.DecodeType.ToLower()) { case "base64": { decodedString = Base64.ToString(decodeOptions.InputToDecode); } break; case "hex": { decodedString = Hexadecimal.ToString(decodeOptions.InputToDecode); } break; default: errorMsg = $"Unknown decode type \"{decodeOptions.DecodeType}\"."; break; } if (string.IsNullOrWhiteSpace(errorMsg)) { Console.WriteLine(decodedString); return(ExitCode.Sucess); } else { Console.WriteLine(errorMsg); return(ExitCode.Error); } }
/// <summary> /// 电网数据解析 /// </summary> /// <param name="sender">数据</param> private void MyEvent(object sender) { try { XFPowerGridData pg = new XFPowerGridData(); byte[] date = sender as byte[]; string strMsg = Encoding.Default.GetString(date, 0, date.Length);// 将接受到的字节数据转化成字符串; strMsg = strMsg.Trim('\0'); int x = 0; string w = ""; foreach (char item in strMsg) { if (x == 1) { w += item + " "; x = 0; } else { w += item; x++; } } w = w.Substring(0, w.Length - " ".Length); string[] msg = w.Split(' '); if (msg.Length == 18) { if (msg[0] == "3A" && msg[16] == "0A") { pg.LowerComputerId = int.Parse(Hexadecimal.ConvertBase(msg[1], 16, 10)); pg.IsClearAlarm = int.Parse(Hexadecimal.ConvertBase(msg[14], 16, 10)); pg.LowerComputerIsPowerOn = int.Parse(Hexadecimal.ConvertBase(msg[15], 16, 10)); pg.ExtensionComputerId = int.Parse(Hexadecimal.ConvertBase(msg[17], 16, 10)); pg.PowerGridState = int.Parse(Hexadecimal.ConvertBase(msg[2], 16, 10)); if (pg.ExtensionComputerId == 0 && pg.PowerGridState == 0) { return; } pg.CombatPower = int.Parse(Hexadecimal.ConvertBase(msg[3], 16, 10)); pg.Triggerthreshold = int.Parse(Hexadecimal.ConvertBase(msg[4], 16, 10)); pg.ExtensionState = int.Parse(Hexadecimal.ConvertBase(msg[5], 16, 10)); ////下位机状态 //if (pg.PowerGridState == 0) state = pg.ExtensionState; //else if (pg.PowerGridState == 4 || pg.PowerGridState == 1 || pg.PowerGridState == 3) //主机状态 // state = pg.ExtensionState = 5; pg.PowerFlow = int.Parse(Hexadecimal.ConvertBase(msg[8], 16, 10)) * 256 + int.Parse(Hexadecimal.ConvertBase(msg[9], 16, 10)); if (pg.ExtensionComputerId == 0 || (pg.PowerFlow == 0 && pg.Voltage == 0)) { return; } if (int.Parse(Hexadecimal.ConvertBase(msg[10], 16, 10)) * 256 + int.Parse(Hexadecimal.ConvertBase(msg[11], 16, 10)) == 0) { pg.Voltage = (int.Parse(Hexadecimal.ConvertBase(msg[6], 16, 10)) * 256 + int.Parse(Hexadecimal.ConvertBase(msg[7], 16, 10))) % 1000 + 4700; } else { pg.Voltage = (int.Parse(Hexadecimal.ConvertBase(msg[6], 16, 10)) * 256 + int.Parse(Hexadecimal.ConvertBase(msg[7], 16, 10))) % 1000 + 10000; } pg.DeviceIp = powerIp; pg.EventType = (XFPowerState)Enum.Parse(typeof(XFPowerState), state.ToString()); XFZoomStatus?.Invoke(pg); checkTime = DateTime.Now; isSendNetState = false; } } else { return; } string status = Enum.GetName(typeof(XFPowerState), state); w = string.Format("{0}:电压{1} {4} 电流{2} {5} 状态 {3};", pg.ExtensionComputerId, pg.Voltage, pg.PowerFlow, status, "V", "mA"); ShowMsg(w); if (pg.ExtensionComputerId <= ZoomCount) { allZoomData.Add(pg); } stateCount += state; if (pg.ExtensionComputerId == ZoomCount) { if (allZoomData.Count == ZoomCount) { XFPowerGridFormatStatus?.Invoke((XFPowerState)Enum.Parse(typeof(XFPowerState), stateCount == 0 ? "0" : "7"), allZoomData); } allZoomData.Clear(); } // checkTime = DateTime.Now; } catch (Exception) { } }