/// <summary>
/// 바이트 배열을 받아 Hex Code로 Dump해서 문자열로 만든다.
/// Ultra Edit의 Hex Code Editor에 나타내는 것 처럼
/// </summary>
/// <param name="data">원본 데이타</param>
/// <returns>
/// 야래와 같은 형식의 문자열을 반환한다.<br/>
/// LINE####: XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX CCCCCCCCCCCCCCCC
/// </returns>
public static string GetHexDumpString(this byte[] data)
{
if (ArrayTool.IsZeroLengthArray(data))
{
return(string.Empty);
}
// 속도를 높히기 위해서 StringBuilder에 Initail capacity를 충분히 준다.
//
var result = new StringBuilder(data.Length * 6);
int dataLength = data.Length;
for (int r = 0; r < dataLength; r += 16)
{
result.AppendFormat("{0, 8:}: ", r);
// Hex Code 넣기
//
for (var c = 0; c < 16; c++)
{
if (r + c < data.Length)
{
result.AppendFormat("{0:X2}", data[r + c]);
}
else
{
result.Append(" ");
}
if (c % 4 == 3)
{
result.Append(" ");
}
}
// 옆에 Char 표시
//
for (var c = 0; c < 16; c++)
{
if (r + c < data.Length)
{
if (data[r + c] < 32 || data[r + c] > 255)
{
result.Append(".");
}
else
{
result.Append((char)data[r + c]);
}
}
else
{
result.Append(" ");
}
}
result.Append(Environment.NewLine);
}
return(result.ToString());
}
/// <summary>
/// Byte 배열을 Hex 형식의 string으로 변환한다.
/// </summary>
/// <remarks>byte.AsString("X2") 를 사용한다.</remarks>
/// <param name="bytes">바이트 배열</param>
/// <param name="delimiter">구분자</param>
/// <returns>16진수 형식의 문자열</returns>
public static string GetHexStringFromBytes(this byte[] bytes, string delimiter = null)
{
if (ArrayTool.IsZeroLengthArray(bytes))
{
return(string.Empty);
}
delimiter = delimiter ?? string.Empty;
var result = new StringBuilder(bytes.Length * (delimiter.Length + 2));
var first = true;
for (var i = 0; i < bytes.Length; i++)
{
if (!first)
{
result.Append(delimiter);
}
result.Append(bytes[i].ToString("X2", CultureInfo.InvariantCulture));
if (first)
{
first = false;
}
}
return(result.ToString());
}
public void Base64Test()
{
TestTool
.RunTasks(ThreadCount,
() => {
var encodedStr = originalData.EncodeBase64();
var decodedData = encodedStr.DecodeBase64();
// Console.WriteLine("Encoded String: " + encodedStr);
Assert.IsTrue(ArrayTool.Compare(originalData, decodedData));
});
}
public void EnsureCapacityTest()
{
const int Length = 10;
var array = new int[Length];
ArrayTool.InitArray(array);
ArrayTool.EnsureCapacity(ref array, 100);
Console.WriteLine("Array length=" + array.Length);
Assert.AreEqual(100, array.Length);
}
public void Params_CombineInOrder_Test(int x, int y, int z, int k)
{
var codes = new[] { x, y, z, k };
var codesReverse = codes.Reverse().ToArray();
int hash1 = HashTool.Compute(codes);
int hash2 = HashTool.Compute(codesReverse);
if (ArrayTool.Compare(codes, codesReverse))
{
Assert.AreEqual(hash1, hash2, "hash1={0}, hash2={1}", hash1, hash2);
}
else
{
Assert.AreNotEqual(hash1, hash2, "hash1={0}, hash2={1}", hash1, hash2);
}
}
public void Params_Combine_Test(int x, int y, int z, int k)
{
var codes = new[] { x, y, z, k };
var codesReverse = new[] { k, z, y, x };
var hash1 = HashTool.Compute(codes);
var hash2 = HashTool.Compute(codesReverse);
if (ArrayTool.Compare(codes, codesReverse))
{
Assert.AreEqual(hash1, hash2, "두 Array의 값이 같다면, HashCode 값도 같아야 합니다.");
}
else
{
Assert.AreNotEqual(hash1, hash2, "HashTool.Compute은 입력 값의 순서에 따라서도 HashCode 값이 달라야 합니다.");
}
}
/// <summary>
/// 지정된 스트림 객체의 내용을 byte 배열로 변환한다. (멀티바이트 언어를 나타내는 접두사(3바이트)가 붙을 경우, 제거하고 반환합니다.)
/// </summary>
/// <param name="stream">변환할 스트림</param>
/// <returns>변환된 바이트 배열</returns>
public static byte[] ToBytes(this Stream stream)
{
const int BUFFER_SIZE = 4096;
if (stream == null)
{
return(new byte[0]);
}
if (IsDebugEnabled)
{
log.Debug("지정한 스트림을 바이트 배열로 변환합니다. 만약 멀티바이트 접두사가 있다면, 삭제하고 반한합니다...");
}
byte[] result = null;
if (stream.CanSeek)
{
result = new byte[stream.Length];
stream.SetStreamPosition();
stream.Read(result, 0, result.Length);
}
else
{
using (var outStream = new MemoryStream(BUFFER_SIZE)) {
int readCount;
var buffer = new byte[BUFFER_SIZE];
while ((readCount = stream.Read(buffer, 0, buffer.Length)) > 0)
{
outStream.Write(buffer, 0, readCount);
}
result = outStream.ToArray();
}
}
// NOTE : 다국어일 경우 Header에 붙는 접두사가 붙는다. 이것을 제거하고 반환한다.
//
if (result.Length >= 3 && ArrayTool.CompareBytes(MultiBytesPrefixBytes, ArrayTool.Copy(result, 0, 3)))
{
result = ArrayTool.Copy(result, 3, result.Length - 3);
}
return(result);
}
public void CompareTest()
{
const int Length = 10;
var array1 = new string[Length];
var array2 = new string[Length];
for (int i = 0; i < Length; i++)
{
array1[i] = i.ToString();
}
for (int i = 0; i < Length; i++)
{
array2[i] = i.ToString();
}
Assert.IsTrue(ArrayTool.Compare(array1, array2));
}
public void CombineTest()
{
const int Length = 10;
var array1 = new int[Length];
var array2 = new int[Length];
for (int i = 0; i < Length; i++)
{
array1[i] = i;
}
for (int i = 0; i < Length; i++)
{
array2[i] = i;
}
var array3 = ArrayTool.Combine(array1, array2);
Assert.AreEqual(Length * 2, array3.Length);
}