public static int IndexOf <T>(T[] array, T value, int startIndex, int count)
{
if (array == null)
{
ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
}
if ((uint)startIndex > (uint)array.Length)
{
ThrowHelper.ThrowStartIndexArgumentOutOfRange_ArgumentOutOfRange_Index();
}
if ((uint)count > (uint)(array.Length - startIndex))
{
ThrowHelper.ThrowCountArgumentOutOfRange_ArgumentOutOfRange_Count();
}
if (RuntimeHelpers.IsBitwiseEquatable <T>())
{
if (Unsafe.SizeOf <T>() == sizeof(byte))
{
int result = SpanHelpers.IndexOf(
ref Unsafe.Add(ref array.GetRawSzArrayData(), startIndex),
Unsafe.As <T, byte>(ref value),
count);
return((result >= 0 ? startIndex : 0) + result);
}
else if (Unsafe.SizeOf <T>() == sizeof(char))
{
int result = SpanHelpers.IndexOf(
ref Unsafe.Add(ref Unsafe.As <byte, char>(ref array.GetRawSzArrayData()), startIndex),
Unsafe.As <T, char>(ref value),
count);
return((result >= 0 ? startIndex : 0) + result);
}
else if (Unsafe.SizeOf <T>() == sizeof(int))
{
int result = SpanHelpers.IndexOf(
ref Unsafe.Add(ref Unsafe.As <byte, int>(ref array.GetRawSzArrayData()), startIndex),
Unsafe.As <T, int>(ref value),
count);
return((result >= 0 ? startIndex : 0) + result);
}
else if (Unsafe.SizeOf <T>() == sizeof(long))
{
int result = SpanHelpers.IndexOf(
ref Unsafe.Add(ref Unsafe.As <byte, long>(ref array.GetRawSzArrayData()), startIndex),
Unsafe.As <T, long>(ref value),
count);
return((result >= 0 ? startIndex : 0) + result);
}
}
return(EqualityComparer <T> .Default.IndexOf(array, value, startIndex, count));
}
public static ulong ToUInt64(byte[] value, int startIndex)
{
if (value == null)
{
ThrowHelper.ThrowArgumentNullException(ExceptionArgument.value);
}
if ((uint)startIndex >= value.Length)
{
ThrowHelper.ThrowStartIndexArgumentOutOfRange_ArgumentOutOfRange_Index();
}
if (startIndex > value.Length - 8)
{
ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_ArrayPlusOffTooSmall);
}
Contract.EndContractBlock();
return((ulong)ToInt64(value, startIndex));
}
[System.Security.SecuritySafeCritical] // auto-generated
unsafe public static float ToSingle(byte[] value, int startIndex)
{
if (value == null)
{
ThrowHelper.ThrowArgumentNullException(ExceptionArgument.value);
}
if ((uint)startIndex >= value.Length)
{
ThrowHelper.ThrowStartIndexArgumentOutOfRange_ArgumentOutOfRange_Index();
}
if (startIndex > value.Length - 4)
{
ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_ArrayPlusOffTooSmall);
}
Contract.EndContractBlock();
int val = ToInt32(value, startIndex);
return(*(float *)&val);
}
[System.Security.SecuritySafeCritical] // auto-generated
public static unsafe long ToInt64(byte[] value, int startIndex)
{
if (value == null)
{
ThrowHelper.ThrowArgumentNullException(ExceptionArgument.value);
}
if ((uint)startIndex >= value.Length)
{
ThrowHelper.ThrowStartIndexArgumentOutOfRange_ArgumentOutOfRange_Index();
}
if (startIndex > value.Length - 8)
{
ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_ArrayPlusOffTooSmall);
}
Contract.EndContractBlock();
fixed(byte *pbyte = &value[startIndex])
{
if (startIndex % 8 == 0) // data is aligned
{
return(*((long *)pbyte));
}
else
{
if (IsLittleEndian)
{
int i1 = (*pbyte) | (*(pbyte + 1) << 8) | (*(pbyte + 2) << 16) | (*(pbyte + 3) << 24);
int i2 = (*(pbyte + 4)) | (*(pbyte + 5) << 8) | (*(pbyte + 6) << 16) | (*(pbyte + 7) << 24);
return((uint)i1 | ((long)i2 << 32));
}
else
{
int i1 = (*pbyte << 24) | (*(pbyte + 1) << 16) | (*(pbyte + 2) << 8) | (*(pbyte + 3));
int i2 = (*(pbyte + 4) << 24) | (*(pbyte + 5) << 16) | (*(pbyte + 6) << 8) | (*(pbyte + 7));
return((uint)i2 | ((long)i1 << 32));
}
}
}
}
[System.Security.SecuritySafeCritical] // auto-generated
public static unsafe int ToInt32(byte[] value, int startIndex)
{
if (value == null)
{
ThrowHelper.ThrowArgumentNullException(ExceptionArgument.value);
}
if ((uint)startIndex >= value.Length)
{
ThrowHelper.ThrowStartIndexArgumentOutOfRange_ArgumentOutOfRange_Index();
}
if (startIndex > value.Length - 4)
{
ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_ArrayPlusOffTooSmall);
}
Contract.EndContractBlock();
fixed(byte *pbyte = &value[startIndex])
{
if (startIndex % 4 == 0) // data is aligned
{
return(*((int *)pbyte));
}
else
{
if (IsLittleEndian)
{
return((*pbyte) | (*(pbyte + 1) << 8) | (*(pbyte + 2) << 16) | (*(pbyte + 3) << 24));
}
else
{
return((*pbyte << 24) | (*(pbyte + 1) << 16) | (*(pbyte + 2) << 8) | (*(pbyte + 3)));
}
}
}
}
