Byte

Core\CSharp\System\Windows\Media\Animation\Generated\ByteAnimation.cs (4)

235Byte from = new Byte(); 236Byte to = new Byte(); 237Byte accumulated = new Byte(); 238Byte foundation = new Byte();

src\Framework\System\Windows\Markup\Baml2006\WpfGeneratedKnownTypes.cs (1)

2328bamlType.DefaultConstructor = delegate() { return new System.Byte(); };

microsoft\win32\oavariantlib.cs (1)

43typeof(Byte),

microsoft\win32\win32native.cs (3)

317public RegistryTimeZoneInformation(Byte[] bytes) { 1734internal static unsafe extern bool ReadConsoleW(SafeFileHandle hConsoleInput, Byte* lpBuffer, Int32 nNumberOfCharsToRead, out Int32 lpNumberOfCharsRead, IntPtr pInputControl); 1743internal static unsafe extern bool WriteConsoleW(SafeFileHandle hConsoleOutput, Byte* lpBuffer, Int32 nNumberOfCharsToWrite, out Int32 lpNumberOfCharsWritten, IntPtr lpReservedMustBeNull);

system\AppDomainSetup.cs (4)

1260internal static bool ByteArraysAreDifferent(Byte[] A, Byte[] B) 1277internal static void UpdateByteArrayContextPropertyIfNeeded(Byte[] NewArray, Byte[] OldArray, String FieldKey, IntPtr fusionContext)

system\byte.cs (11)

35, IComparable<Byte>, IEquatable<Byte> 60if (!(value is Byte)) { 64return m_value - (((Byte)value).m_value); 67public int CompareTo(Byte value) { 73if (!(obj is Byte)) { 76return m_value == ((Byte)obj).m_value; 80public bool Equals(Byte obj) 129public static bool TryParse(String s, out Byte result) { 133public static bool TryParse(String s, NumberStyles style, IFormatProvider provider, out Byte result) { 138private static bool TryParse(String s, NumberStyles style, NumberFormatInfo info, out Byte result) {

system\convert.cs (32)

122(RuntimeType)typeof(Byte), 725if (value > Byte.MaxValue) throw new OverflowException(Environment.GetResourceString("Overflow_Byte")); 732if (value < Byte.MinValue) throw new OverflowException(Environment.GetResourceString("Overflow_Byte")); 738if (value < Byte.MinValue || value > Byte.MaxValue) throw new OverflowException(Environment.GetResourceString("Overflow_Byte")); 745if (value > Byte.MaxValue) throw new OverflowException(Environment.GetResourceString("Overflow_Byte")); 751if (value < Byte.MinValue || value > Byte.MaxValue) throw new OverflowException(Environment.GetResourceString("Overflow_Byte")); 758if (value > Byte.MaxValue) throw new OverflowException(Environment.GetResourceString("Overflow_Byte")); 764if (value < Byte.MinValue || value > Byte.MaxValue) throw new OverflowException(Environment.GetResourceString("Overflow_Byte")); 771if (value > Byte.MaxValue) throw new OverflowException(Environment.GetResourceString("Overflow_Byte")); 791return Byte.Parse(value, CultureInfo.CurrentCulture); 797return Byte.Parse(value, NumberStyles.Integer, provider); 1983if (r < Byte.MinValue || r > Byte.MaxValue) 1999if (fromBase != 10 && r <= Byte.MaxValue) 2345public static Byte[] FromBase64String(String s) { 2371public static Byte[] FromBase64CharArray(Char[] inArray, Int32 offset, Int32 length) { 2420private static unsafe Byte[] FromBase64CharPtr(Char* inputPtr, Int32 inputLength) { 2445Byte[] decodedBytes = new Byte[resultLength]; 2449fixed (Byte* decodedBytesPtr = decodedBytes) 2474private static unsafe Int32 FromBase64_Decode(Char* startInputPtr, Int32 inputLength, Byte* startDestPtr, Int32 destLength) { 2493Byte* destPtr = startDestPtr; 2497Byte* endDestPtr = destPtr + destLength; 2563*(destPtr) = (Byte) (currBlockCodes >> 16); 2564*(destPtr + 1) = (Byte) (currBlockCodes >> 8); 2565*(destPtr + 2) = (Byte) (currBlockCodes); 2596*(destPtr++) = (Byte) (currBlockCodes >> 16); 2597*(destPtr++) = (Byte) (currBlockCodes >> 8); 2626*(destPtr++) = (Byte) (currBlockCodes >> 16);

system\decimal.cs (2)

830if (temp < Byte.MinValue || temp > Byte.MaxValue) throw new OverflowException(Environment.GetResourceString("Overflow_Byte"));

system\diagnostics\eventing\eventsource.cs (1)

1626foreach (var b in input)

System\Diagnostics\Eventing\TraceLogging\SimpleTypeInfos.cs (5)

66: TraceLoggingTypeInfo<Byte> 76public override void WriteData(TraceLoggingDataCollector collector, ref Byte value) 350: TraceLoggingTypeInfo<Byte[]> 388public override void WriteData(TraceLoggingDataCollector collector, ref Byte[] value) 651collector.AddScalar(EnumHelper<Byte>.Cast(value));

System\Diagnostics\Eventing\TraceLogging\Statics.cs (3)

605else if (elementType == typeof(Byte)) 679else if (underlyingType == typeof(Byte)) 717else if (dataType == typeof(Byte))

System\Diagnostics\Eventing\TraceLogging\TraceLoggingEventSource.cs (1)

765foreach (var b in traitMetaData)

system\enum.cs (3)

58Byte result = (byte)(sbyte)value; 65Byte result = (byte)value; 73Byte result = Convert.ToByte((bool)value);

system\globalization\compareinfo.cs (1)

1103keyData = EmptyArray<Byte>.Value;

system\internal.cs (5)

65new Dictionary<Guid, Byte>(); 69new Dictionary<Int32, Byte>(); 97NullableHelper<Byte>(); 111new List<Byte>(); 136SZArrayHelper<Byte>(null);

system\io\binaryreader.cs (1)

529return EmptyArray<Byte>.Value;

system\io\bufferedstream.cs (19)

system\io\filestream.cs (2)

2603public override Task<int> ReadAsync(Byte[] buffer, int offset, int count, CancellationToken cancellationToken) 2655public override Task WriteAsync(Byte[] buffer, int offset, int count, CancellationToken cancellationToken)

system\io\memorystream.cs (2)

375public override Task<int> ReadAsync(Byte[] buffer, int offset, int count, CancellationToken cancellationToken) 602public override Task WriteAsync(Byte[] buffer, int offset, int count, CancellationToken cancellationToken)

system\io\stream.cs (8)

410public Task<int> ReadAsync(Byte[] buffer, int offset, int count) 417public virtual Task<int> ReadAsync(Byte[] buffer, int offset, int count, CancellationToken cancellationToken) 426private Task<Int32> BeginEndReadAsync(Byte[] buffer, Int32 offset, Int32 count) 705public Task WriteAsync(Byte[] buffer, int offset, int count) 712public virtual Task WriteAsync(Byte[] buffer, int offset, int count, CancellationToken cancellationToken) 722private Task BeginEndWriteAsync(Byte[] buffer, Int32 offset, Int32 count) 946public override Task<int> ReadAsync(Byte[] buffer, int offset, int count, CancellationToken cancellationToken) 967public override Task WriteAsync(Byte[] buffer, int offset, int count, CancellationToken cancellationToken)

system\io\streamreader.cs (4)

943Byte[] tmpByteBuffer = ByteBuffer_Prop; 1148private Byte[] Preamble_Prop { 1168private Byte[] ByteBuffer_Prop { 1189Byte[] tmpByteBuffer = ByteBuffer_Prop;

system\io\streamwriter.cs (1)

839Encoding encoding, Encoder encoder, Byte[] byteBuffer, Stream stream)

system\io\unmanagedmemorystream.cs (2)

448public override Task<Int32> ReadAsync(Byte[] buffer, Int32 offset, Int32 count, CancellationToken cancellationToken) { 644public override Task WriteAsync(Byte[] buffer, Int32 offset, Int32 count, CancellationToken cancellationToken) {

system\io\unmanagedmemorystreamwrapper.cs (2)

186public override Task<Int32> ReadAsync(Byte[] buffer, Int32 offset, Int32 count, CancellationToken cancellationToken) { 192public override Task WriteAsync(Byte[] buffer, Int32 offset, Int32 count, CancellationToken cancellationToken) {

system\number.cs (31)

system\random.cs (1)

210buffer[i]=(byte)(InternalSample()%(Byte.MaxValue+1));

system\reflection\emit\assemblybuilder.cs (2)

1480public void DefineUnmanagedResource(Byte[] resource) 1492private void DefineUnmanagedResourceNoLock(Byte[] resource)

system\reflection\emit\dynamicilgenerator.cs (6)

1030m_exceptions = EmptyArray<Byte>.Value; 1031m_code = EmptyArray<Byte>.Value; 1032m_localSignature = EmptyArray<Byte>.Value; 1065m_code = (code != null) ? (byte[])code.Clone() : EmptyArray<Byte>.Value; 1092m_exceptions = (exceptions != null) ? (byte[])exceptions.Clone() : EmptyArray<Byte>.Value; 1117m_localSignature = (localSignature != null) ? (byte[])localSignature.Clone() : EmptyArray<Byte>.Value;

system\reflection\emit\ilgenerator.cs (1)

939if (tempVal > Byte.MaxValue)

system\reflection\emit\modulebuilder.cs (2)

1391public void DefineUnmanagedResource(Byte[] resource) 1399internal void DefineUnmanagedResourceInternalNoLock(Byte[] resource)

system\resources\resourcereader.cs (1)

619else if (type == typeof(Byte))

system\resources\resourcewriter.cs (1)

539else if (type == typeof(Byte))

system\runtime\compilerservices\AsyncMethodBuilder.cs (3)

775(typeof(TResult) == typeof(Byte) && default(Byte) == (Byte)(object)result) ||

system\runtime\interopservices\ComTypes\istream.cs (2)

43void Read([MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 1), Out] Byte[] pv, int cb, IntPtr pcbRead); 44void Write([MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 1)] Byte[] pv, int cb, IntPtr pcbWritten);

system\runtime\interopservices\tceadaptergen\eventproviderwriter.cs (6)

8using ubyte = System.Byte; 470ubyte[] rgByteGuid = new ubyte[16]; 474aParamTypes[0] = typeof(Byte[]); 494LocalBuilder ltByteArrayGuid = il.DeclareLocal( typeof(Byte[]) ); 507il.Emit( OpCodes.Newarr, typeof(Byte) );

system\runtime\interopservices\ucomistream.cs (2)

45void Read([MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 1), Out] Byte[] pv, int cb,IntPtr pcbRead); 46void Write([MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 1)] Byte[] pv, int cb, IntPtr pcbWritten);

system\Runtime\InteropServices\Variant.cs (2)

79[FieldOffset(0)] internal Byte _ui1; 430public Byte AsUi1 {

system\runtime\interopservices\windowsruntime\clripropertyvalueimpl.cs (6)

36new Tuple<Type, PropertyType>(typeof(Byte), PropertyType.UInt8), 79public Byte GetUInt8() 81return CoerceScalarValue<Byte>(PropertyType.UInt8); 224public Byte[] GetUInt8Array() 226return CoerceArrayValue<Byte>(PropertyType.UInt8Array); 450if (typeof(T) == typeof(Byte)) {

system\runtime\interopservices\windowsruntime\ipropertyvalue.cs (2)

34Byte GetUInt8(); 88Byte[] GetUInt8Array();

system\runtime\remoting\identity.cs (2)

188private static Byte[] GetRandomBytes() 197Byte[] randomBytes = new byte[18];

system\runtime\remoting\soapinteroptypes.cs (16)

898Byte[] _value; 917public SoapHexBinary(Byte[] value) 923public Byte[] Value 952private static Byte[] ToByteArray(String value) 962Byte[] bA = new Byte[cA.Length/2]; 965bA[i] = (Byte)(ToByte(cA[i*2], value)*16+ToByte(cA[i*2+1], value)); 971private static Byte ToByte(Char c, String value) 973Byte b = (Byte)0; 978b = Byte.Parse(s, NumberStyles.HexNumber, CultureInfo.InvariantCulture); 994Byte[] _value; 1014public SoapBase64Binary(Byte[] value) 1020public Byte[] Value 1039return new SoapBase64Binary(new Byte[0]); 1041Byte[] bA;

system\runtime\serialization\formatter.cs (1)

147} else if (varType==typeof(Byte)) {

system\runtime\serialization\formatters\binary\binarycommonclasses.cs (32)

system\runtime\serialization\formatters\binary\binaryconverter.cs (3)

286array = new Byte[length]; 493internal static Type typeofByte = typeof(Byte); 518internal static Type typeofByteArray = typeof(Byte[]);

system\runtime\serialization\formatters\binary\binaryformatterwriter.cs (5)

72internal void WriteByte(Byte value) 77private void WriteBytes(Byte[] value) 130WriteByte((Byte)value); 385WriteBytes((Byte[])array); 509internal void WriteObjectByteArray(NameInfo memberNameInfo, NameInfo arrayNameInfo, WriteObjectInfo objectInfo, NameInfo arrayElemTypeNameInfo, int length, int lowerBound, Byte[] byteA)

system\runtime\serialization\formatters\binary\binaryobjectreader.cs (1)

681pr.PRnewObj = new Byte[0];

system\runtime\serialization\formatters\binary\binaryparser.cs (3)

125Byte inByte = dataReader.ReadByte(); 282internal Byte ReadByte() 287internal Byte[] ReadBytes(int length)

system\sbyte.cs (2)

156if ((i < 0) || i > Byte.MaxValue) { 186if ((i < 0) || i > Byte.MaxValue) {

system\security\cryptography\base64transforms.cs (2)

78return(EmptyArray<Byte>.Value); 212return (EmptyArray<Byte>.Value);

system\security\cryptography\cryptoapitransform.cs (1)

193Utils._EncryptData(_safeKeyHandle, EmptyArray<Byte>.Value, 0, 0, ref temp, 0, PaddingValue, true);

system\security\cryptography\hashalgorithm.cs (1)

181outputBytes = EmptyArray<Byte>.Value;

system\security\cryptography\hmac.cs (2)

148m_hash1.TransformFinalBlock(EmptyArray<Byte>.Value, 0, 0); 155m_hash2.TransformFinalBlock(EmptyArray<Byte>.Value, 0, 0);

system\security\cryptography\passwordderivebytes.cs (1)

249_hash.TransformFinalBlock(EmptyArray<Byte>.Value, 0, 0);

system\security\cryptography\rfc2898derivebytes.cs (2)

231m_hmac.TransformFinalBlock(EmptyArray<Byte>.Value, 0, 0); 238m_hmac.TransformFinalBlock(EmptyArray<Byte>.Value, 0, 0);

system\security\cryptography\utils.cs (2)

813hash.ComputeHash(EmptyArray<Byte>.Value); // Use an empty octet string 903hash.ComputeHash(EmptyArray<Byte>.Value);

system\security\principal\win32.cs (3)

306byte[] BinaryForm1 = new Byte[sid1.BinaryLength]; 309byte[] BinaryForm2 = new Byte[sid2.BinaryLength]; 382byte[] BinaryForm = new Byte[sid.BinaryLength];

system\text\basecodepageencoding.cs (1)

278Byte *pMemorySection = EncodingTable.nativeCreateOpenFileMapping(strName, iSize, out mappedFileHandle);

system\text\encoding.cs (1)

713return EmptyArray<Byte>.Value;

system\text\unicodeencoding.cs (1)

1940return EmptyArray<Byte>.Value;

system\text\utf32encoding.cs (1)

1204return EmptyArray<Byte>.Value;

system\text\utf8encoding.cs (1)

2398return EmptyArray<Byte>.Value;

system\threading\volatile.cs (1)

63var value = location;

system\timezoneinfo.cs (9)

2353Byte[] regValue = dynamicKey.GetValue(first.ToString(CultureInfo.InvariantCulture), null, RegistryValueOptions.None) as Byte[]; 2389regValue = dynamicKey.GetValue(i.ToString(CultureInfo.InvariantCulture), null, RegistryValueOptions.None) as Byte[]; 2405regValue = dynamicKey.GetValue(last.ToString(CultureInfo.InvariantCulture), null, RegistryValueOptions.None) as Byte[]; 2503Byte[] regValue = (Byte[])key.GetValue(c_timeZoneInfoValue, null, RegistryValueOptions.None) as Byte[]; 2789Byte[] regValue = key.GetValue(c_timeZoneInfoValue, null, RegistryValueOptions.None) as Byte[];

system\variant.cs (1)

96typeof(Byte),

Base\System\Windows\Markup\TypeConverterHelper.cs (1)

213else if (typeof(Byte).IsAssignableFrom(type))

Core\CSharp\MS\internal\Media\ParserStreamGeometryContext.cs (1)

674Byte packedByte = PackByte(opCode, bool1, bool2);

Framework\System\Windows\Markup\BamlRecords.cs (1)

4848bamlBinaryWriter.Write((Byte)AttributeUsage);

Framework\System\Windows\Markup\KnownTypes.cs (1)

5499case KnownElements.Byte: t = typeof(Byte); break;

Core\CSharp\MS\Internal\AnimatedTypeHelpers.cs (20)

18internal static Byte InterpolateByte(Byte from, Byte to, Double progress) 20return (Byte)((Int32)from + (Int32)((((Double)(to - from)) + (Double)0.5) * progress)); 157internal static Byte AddByte(Byte value1, Byte value2) 159return (Byte)(value1 + value2); 259internal static Byte SubtractByte(Byte value1, Byte value2) 261return (Byte)(value1 - value2); 366internal static Double GetSegmentLengthByte(Byte from, Byte to) 507internal static Byte ScaleByte(Byte value, Double factor) 509return (Byte)((Double)value * factor); 610internal static bool IsValidAnimationValueByte(Byte value) 757internal static Byte GetZeroValueByte(Byte baseValue)

Core\CSharp\MS\Internal\Ink\InkSerializedFormat\MetricEntry.cs (1)

51private byte[] _data = new Byte[MAX_METRIC_DATA_BUFF]; // We always allocate the max buffer needed to store the largest possible Metric Information blob

Core\CSharp\MS\Internal\Media\ParserStreamGeometrycontext.cs (10)

316Byte currentByte; 381private static void DeserializeFillRule(BinaryReader br, Byte firstByte, StreamGeometry geometry) 395private static void DeserializeBeginFigure(BinaryReader br, Byte firstByte, StreamGeometryContext sc) 406private static void DeserializeLineTo(BinaryReader br, Byte firstByte, StreamGeometryContext sc) 452private static void DeserializePolyLineTo(BinaryReader br, Byte firstByte, StreamGeometryContext sc) 463private static void DeserializePolyQuadraticBezierTo(BinaryReader br, Byte firstByte, StreamGeometryContext sc) 474private static void DeserializePolyBezierTo(BinaryReader br, Byte firstByte, StreamGeometryContext sc) 540private static IList<Point> DeserializeListOfPointsAndTwoBools(BinaryReader br, Byte firstByte, out bool bool1, out bool bool2) 565private static void DeserializePointAndTwoBools(BinaryReader br, Byte firstByte, out Point point, out bool bool1, out bool bool2) 674Byte packedByte = PackByte(opCode, bool1, bool2);

Core\CSharp\System\Windows\Input\TextCompositionManager.cs (8)

514Byte[] bytes = ConvertCodeToByteArray(code); 996private static Byte[] ConvertCodeToByteArray(int codeEntry) 998Byte[] bytes; 1001bytes = new Byte[2]; 1002bytes[0] = (Byte)(codeEntry >> 8); 1003bytes[1] = (Byte)codeEntry; 1007bytes = new Byte[1]; 1008bytes[0] = (Byte)codeEntry;

Core\CSharp\System\Windows\Media\Animation\Generated\ByteAnimation.cs (32)

45private Byte[] _keyValues; 60Type typeofProp = typeof(Byte?); 69new PropertyMetadata((Byte?)null, propCallback), 76new PropertyMetadata((Byte?)null, propCallback), 83new PropertyMetadata((Byte?)null, propCallback), 107public ByteAnimation(Byte toValue, Duration duration) 119public ByteAnimation(Byte toValue, Duration duration, FillBehavior fillBehavior) 132public ByteAnimation(Byte fromValue, Byte toValue, Duration duration) 145public ByteAnimation(Byte fromValue, Byte toValue, Duration duration, FillBehavior fillBehavior) 218protected override Byte GetCurrentValueCore(Byte defaultOriginValue, Byte defaultDestinationValue, AnimationClock animationClock) 235Byte from = new Byte(); 236Byte to = new Byte(); 237Byte accumulated = new Byte(); 238Byte foundation = new Byte(); 352Byte accumulator = AnimatedTypeHelpers.SubtractByte(to, from); 377_keyValues = new Byte[2]; 384_keyValues = new Byte[2]; 391_keyValues = new Byte[1]; 398_keyValues = new Byte[1]; 404_keyValues = new Byte[1]; 425Byte? typedValue = (Byte?)value; 445public Byte? From 449return (Byte?)GetValue(FromProperty); 465public Byte? To 469return (Byte?)GetValue(ToProperty); 485public Byte? By 489return (Byte?)GetValue(ByProperty);

Core\CSharp\System\Windows\Media\Animation\Generated\ByteAnimationBase.cs (9)

103return GetCurrentValue((Byte)defaultOriginValue, (Byte)defaultDestinationValue, animationClock); 115return typeof(Byte); 152public Byte GetCurrentValue(Byte defaultOriginValue, Byte defaultDestinationValue, AnimationClock animationClock) 215protected abstract Byte GetCurrentValueCore(Byte defaultOriginValue, Byte defaultDestinationValue, AnimationClock animationClock);

Core\CSharp\System\Windows\Media\Animation\Generated\ByteAnimationUsingKeyFrames.cs (8)

331protected sealed override Byte GetCurrentValueCore( 332Byte defaultOriginValue, 333Byte defaultDestinationValue, 359Byte currentIterationValue; 395Byte fromValue; 643private Byte GetResolvedKeyFrameValue(Int32 resolvedKeyFrameIndex) 954Byte prevKeyValue = _keyFrames[index - 1].Value; 958Byte currentKeyValue = _keyFrames[index].Value;

Core\CSharp\System\Windows\Media\Animation\Generated\DiscreteKeyFrames.cs (4)

128public DiscreteByteKeyFrame(Byte value) 136public DiscreteByteKeyFrame(Byte value, KeyTime keyTime) 164protected override Byte InterpolateValueCore(Byte baseValue, double keyFrameProgress)

Core\CSharp\System\Windows\Media\Animation\Generated\EasingKeyFrames.cs (5)

51public EasingByteKeyFrame(Byte value) 60public EasingByteKeyFrame(Byte value, KeyTime keyTime) 70public EasingByteKeyFrame(Byte value, KeyTime keyTime, IEasingFunction easingFunction) 99protected override Byte InterpolateValueCore(Byte baseValue, double keyFrameProgress)

Core\CSharp\System\Windows\Media\Animation\Generated\KeyFrames.cs (10)

192protected ByteKeyFrame(Byte value) 201protected ByteKeyFrame(Byte value, KeyTime keyTime) 244typeof(Byte), 259Value = (Byte)value; 266public Byte Value 270return (Byte)GetValue(ValueProperty); 287public Byte InterpolateValue( 288Byte baseValue, 308protected abstract Byte InterpolateValueCore( 309Byte baseValue,

Core\CSharp\System\Windows\Media\Animation\Generated\LinearKeyFrames.cs (4)

51public LinearByteKeyFrame(Byte value) 59public LinearByteKeyFrame(Byte value, KeyTime keyTime) 85protected override Byte InterpolateValueCore(Byte baseValue, double keyFrameProgress)

Core\CSharp\System\Windows\Media\Animation\Generated\SplineKeyFrames.cs (5)

51public SplineByteKeyFrame(Byte value) 60public SplineByteKeyFrame(Byte value, KeyTime keyTime) 70public SplineByteKeyFrame(Byte value, KeyTime keyTime, KeySpline keySpline) 104protected override Byte InterpolateValueCore(Byte baseValue, double keyFrameProgress)

src\Framework\MS\Internal\Data\DefaultValueConverter.cs (2)

538typeof(Byte), typeof(Int16), 545typeof(Int32), typeof(Int64), typeof(Byte), typeof(Int16),

src\Framework\MS\Internal\IO\Packaging\ByteStream.cs (2)

463void Read([MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 1), Out] Byte[] pv, int cb, out int pcbRead); 464void Write([MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 1)] Byte[] pv, int cb, out int pcbWritten);

src\Framework\MS\Internal\IO\Packaging\managedIStream.cs (2)

57void IStream.Read(Byte[] buffer, Int32 bufferSize, IntPtr bytesReadPtr) 165void IStream.Write(Byte[] buffer, Int32 bufferSize, IntPtr bytesWrittenPtr)

src\Framework\System\Windows\Documents\WpfPayload.cs (4)

689Byte[] buffer1 = new Byte[bufferSize]; 690Byte[] buffer2 = new Byte[bufferSize];

src\Framework\System\Windows\Interop\DocobjHost.cs (2)

1313void Read([MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 1), Out] Byte[] pv, int cb, out int pcbRead); 1319void Write([MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 1)] Byte[] pv, int cb, out int pcbWritten);

src\Framework\System\Windows\Markup\Baml2006\Baml2006KnownTypes.cs (1)

149case 57: t = () => typeof(Byte); break;

src\Framework\System\Windows\Markup\Baml2006\WpfGeneratedKnownTypes.cs (1)

2326typeof(System.Byte),

src\Framework\System\Windows\Markup\BamlRecords.cs (1)

4848bamlBinaryWriter.Write((Byte)AttributeUsage);

src\Framework\System\Windows\Markup\KnownTypes.cs (1)

5601case KnownElements.Byte: t = typeof(System.Byte); break;

compmod\microsoft\csharp\csharpcodeprovider.cs (1)

2987foreach(Byte b in checksumPragma.ChecksumData) {

compmod\microsoft\visualbasic\VBCodeProvider.cs (1)

2486foreach(Byte b in checksumPragma.ChecksumData) {

compmod\microsoft\win32\UnsafeNativeMethods.cs (1)

219private static extern Int32 _GetCurrentPackageId(ref Int32 pBufferLength, Byte[] pBuffer);

compmod\system\componentmodel\ByteConverter.cs (4)

32return typeof(Byte); 47return Byte.Parse(value, NumberStyles.Integer, formatInfo); 55return Byte.Parse(value, culture); 62return ((Byte)value).ToString("G", formatInfo);

net\System\Net\Sockets\UDPClient.cs (1)

1031Byte[] buffer = EndReceive(ar, ref remoteEP);

System\Addin\MiniReflection\MetadataReader\Metadata.cs (1)

416Byte[] Result = null;

System\Addin\MiniReflection\MiniParameterInfo.cs (1)

85return new TypeInfo(typeof(Byte));

System\Addin\Contract\RemoteArgument.cs (5)

397public RemoteArgument(System.Byte value) 405public RemoteArgument(System.Byte value, bool isByRef) 865public System.Byte ByteValue 873return default(System.Byte); 879return (System.Byte)this._value;

Microsoft\Scripting\Ast\ParameterExpression.cs (1)

50case TypeCode.Byte: return new PrimitiveParameterExpression<Byte>(name);

Microsoft\Scripting\Compiler\ILGen.cs (3)

68if (index <= Byte.MaxValue) { 80if (index <= Byte.MaxValue) { 90if (index <= Byte.MaxValue) {

Microsoft\Win32\UnsafeNativeMethods.cs (1)

749public Byte ByteVal;

System\Diagnostics\Eventing\Reader\NativeWrapper.cs (3)

1210if (val.Reference == IntPtr.Zero) return new Byte[0]; 1211Byte[] arByte = new Byte[val.Count];

fx\src\data\Microsoft\SqlServer\Server\ITypedGetters.cs (1)

27Byte GetByte( int ordinal );

fx\src\data\Microsoft\SqlServer\Server\ITypedGettersV3.cs (1)

36Byte GetByte( SmiEventSink sink, int ordinal );

fx\src\data\Microsoft\SqlServer\Server\ITypedSetters.cs (1)

22void SetByte( int ordinal, Byte value );

fx\src\data\Microsoft\SqlServer\Server\ITypedSettersV3.cs (1)

38void SetByte( SmiEventSink sink, int ordinal, Byte value );

fx\src\data\Microsoft\SqlServer\Server\MemoryRecordBuffer.cs (2)

50public override Byte GetByte(SmiEventSink sink, int ordinal) { 138public override void SetByte(SmiEventSink sink, int ordinal, Byte value) {

fx\src\data\Microsoft\SqlServer\Server\MetadataUtilsSmi.cs (3)

94ht.Add( typeof( System.Byte ), ExtendedClrTypeCode.Byte ); 111ht.Add( typeof( System.Byte[] ), ExtendedClrTypeCode.ByteArray ); 326if (value.GetType() == typeof( Byte ))

fx\src\data\Microsoft\SqlServer\Server\SmiRecordBuffer.cs (2)

122public virtual Byte GetByte( int ordinal ) { 465public virtual void SetByte( int ordinal, Byte value ) {

fx\src\data\Microsoft\SqlServer\Server\SmiRequestExecutor.cs (2)

180public virtual Byte GetByte( int ordinal ) { 523public virtual void SetByte( int ordinal, Byte value ) {

fx\src\data\Microsoft\SqlServer\Server\SmiTypedGetterSetter.cs (2)

66public virtual Byte GetByte(SmiEventSink sink, int ordinal) { 259public virtual void SetByte(SmiEventSink sink, int ordinal, Byte value) {

fx\src\data\Microsoft\SqlServer\Server\SqlRecordBuffer.cs (2)

42[FieldOffset(0)] internal Byte _byte; 85internal Byte Byte {

fx\src\data\Microsoft\SqlServer\Server\ValueUtilsSmi.cs (4)

81return (Byte)result; 1343internal static void SetByte( SmiEventSink_Default sink, ITypedSettersV3 setters, int ordinal, SmiMetaData metaData, Byte value ) { 1591case ExtendedClrTypeCode.Byte: SetByte_Unchecked( sink, setters, ordinal, (Byte) value ); break; 3280private static void SetByte_Unchecked( SmiEventSink_Default sink, ITypedSettersV3 setters, int ordinal, Byte value ) {

fx\src\data\System\Data\CodeGen\datacache.cs (2)

852col.DataType == typeof(SByte) || col.DataType == typeof(Byte) || 861if(col.DataType == typeof(Byte[])) {

fx\src\data\System\Data\ColumnTypeConverter.cs (2)

26typeof(Byte), 27typeof(Byte[]),

fx\src\data\System\Data\Common\BigIntegerStorage.cs (4)

70else if (value.GetType() == typeof(Byte)) { return (BigInteger)(Byte)value; } 80else if (type == typeof(Byte)) { return checked((Byte)value); }

fx\src\data\System\Data\Common\ByteStorage.cs (22)

18private const Byte defaultValue = 0; 20private Byte[] values; 23: base(column, typeof(Byte), defaultValue, StorageType.Byte) { 54Byte mean; 55checked {mean = (Byte)(meanSum / meanCount);} 97Byte min = Byte.MaxValue; 111Byte max = Byte.MinValue; 136throw ExprException.Overflow(typeof(Byte)); 142Byte valueNo1 = values[recordNo1]; 143Byte valueNo2 = values[recordNo2]; 165Byte valueNo1 = values[recordNo]; 169return valueNo1.CompareTo((Byte)value); 191Byte value = values[record]; 211Byte[] newValues = new Byte[capacity]; 224return XmlConvert.ToString((Byte) value); 228return new Byte[recordCount]; 232Byte[] typedStore = (Byte[]) store; 238values = (Byte[]) store;

fx\src\data\System\Data\Common\DataStorage.cs (1)

77typeof(Byte),

fx\src\data\System\Data\Common\SQLConvert.cs (2)

502return ((IConvertible)(Byte)value).ToString(formatProvider); 749return XmlConvert.ToString((Byte) value);

fx\src\data\System\Data\DataSet.cs (3)

360Byte[] buffer = (Byte[])info.GetValue(String.Format(CultureInfo.InvariantCulture, "DataSet.Tables_{0}", i), typeof(Byte[]));

fx\src\data\System\Data\Filter\UnaryNode.cs (1)

68value = -(Byte) vl;

fx\src\data\System\Data\Odbc\Odbc32.cs (5)

786static internal readonly TypeMap _Image = new TypeMap(OdbcType.Image, DbType.Binary, typeof(Byte[]), ODBC32.SQL_TYPE.LONGVARBINARY, ODBC32.SQL_C.BINARY, ODBC32.SQL_C.BINARY, -1, -1, false); 797static private readonly TypeMap _Timestamp = new TypeMap(OdbcType.Timestamp, DbType.Binary, typeof(Byte[]), ODBC32.SQL_TYPE.BINARY, ODBC32.SQL_C.BINARY, ODBC32.SQL_C.BINARY, -1, -1, false); 798static private readonly TypeMap _TinyInt = new TypeMap(OdbcType.TinyInt, DbType.Byte, typeof(Byte), ODBC32.SQL_TYPE.TINYINT, ODBC32.SQL_C.UTINYINT, ODBC32.SQL_C.UTINYINT, 1, 3, true); 799static private readonly TypeMap _VarBinary = new TypeMap(OdbcType.VarBinary, DbType.Binary, typeof(Byte[]), ODBC32.SQL_TYPE.VARBINARY, ODBC32.SQL_C.BINARY, ODBC32.SQL_C.BINARY, -1, -1, false); 897if (dataType == typeof(System.Byte[])) {

fx\src\data\System\Data\Odbc\OdbcCommandBuilder.cs (2)

226parameter.ScaleInternal = (Byte)reader.GetInt16(ODBC32.DECIMAL_DIGITS-1); 227parameter.PrecisionInternal = (Byte)reader.GetInt16(ODBC32.NUM_PREC_RADIX-1);

fx\src\data\System\Data\Odbc\OdbcDataReader.cs (9)

587override public Byte GetByte(int i) { 588return (Byte)internalGetByte(i); 1282Byte[] rgBytes; 1291rgBytes = new Byte[cbActual]; 1308List<Byte[]> junkArray = new List<Byte[]>(); 1313rgBytes = new Byte[junkSize]; 1320rgBytes = new Byte[totalSize]; 1321foreach(Byte[] junk in junkArray) {

fx\src\data\System\Data\Odbc\OdbcParameter.cs (9)

117Byte precision, 118Byte scale, 139Byte precision, Byte scale, 232[DefaultValue((Byte)0)] // MDAC 65862 235public new Byte Precision { 262[DefaultValue((Byte)0)] // MDAC 65862 265public new Byte Scale { 852Value = cpe.GetString((Byte[])Value);

fx\src\data\System\Data\Odbc\OdbcUtils.cs (5)

66Byte b = ReadByte(offset); 200Byte[] rgBytes = (Byte[])value; 224WriteByte(offset, (Byte)value); 252WriteByte(offset, (Byte)(((bool)value) ? 1 : 0));

fx\src\data\System\Data\OleDb\ColumnBinding.cs (14)

461Value_UI1((Byte) value); 497Value_BYTES((Byte[]) value); 523Value_ByRefBYTES((Byte[]) value); 598private Byte[] Value_ByRefBYTES() { 620private void Value_ByRefBYTES(Byte[] value) { 696private Byte[] Value_BYTES() { 704private void Value_BYTES(Byte[] value) { 862RowBinding.WriteByte(ValueOffset, unchecked((Byte) value)); 1004private Byte Value_UI1() { 1009private void Value_UI1(Byte value) { 1156internal Byte ValueByte() { 1157Byte value; 1165value = (Byte) ValueVariant(); 1172throw CheckTypeValueStatusValue(typeof(Byte));

fx\src\data\System\Data\OleDb\OLEDB_Enum.cs (9)

158static private readonly NativeDBType D_Binary = new NativeDBType(0xff, -1, true, false, OleDbType.Binary, NativeDBType.BYTES, S_BINARY, typeof(System.Byte[]), NativeDBType.BYTES, DbType.Binary ); // 0 177static private readonly NativeDBType D_LongVarBinary = new NativeDBType(0xff, -1, false, true, OleDbType.LongVarBinary, NativeDBType.BYTES, S_LONGVARBINARY, typeof(System.Byte[]), NativeDBType.BYTES, DbType.Binary ); // 19 184static private readonly NativeDBType D_UnsignedTinyInt = new NativeDBType( 3, 1, true, false, OleDbType.UnsignedTinyInt, NativeDBType.UI1, S_UI1, typeof(System.Byte), NativeDBType.UI1, DbType.Byte ); // 25 - byte7 188static private readonly NativeDBType D_VarBinary = new NativeDBType(0xff, -1, false, false, OleDbType.VarBinary, NativeDBType.BYTES, S_VARBINARY, typeof(System.Byte[]), NativeDBType.BYTES, DbType.Binary ); // 29 198static private readonly NativeDBType D_Udt = new NativeDBType(0xff, -1, false, false, OleDbType.VarBinary, NativeDBType.UDT, S_BINARY, typeof(System.Byte[]), NativeDBType.BYTES, DbType.Binary ); // 39 - (unicode pointer) 201static internal readonly Byte MaximumDecimalPrecision = D_Decimal.maxpre; 215internal readonly Byte maxpre; // maxium precision for numeric types // $ 221private NativeDBType(Byte maxpre, int fixlen, bool isfixed, bool islong, OleDbType enumOleDbType, short dbType, string dbstring, Type dataType, short wType, DbType enumDbType) { 317else if (value is System.Byte[]) {

fx\src\data\System\Data\OleDb\OleDbCommandBuilder.cs (2)

235parameter.PrecisionInternal = (Byte) Convert.ToInt16(dataRow[numericPrecision], CultureInfo.InvariantCulture); 239parameter.ScaleInternal = (Byte) Convert.ToInt16(dataRow[numericScale], CultureInfo.InvariantCulture);

fx\src\data\System\Data\OleDb\oledbconnectionstring.cs (2)

294byte[] bytes = new Byte[hdrlength]; 303bytes = new Byte[length - hdrlength];

fx\src\data\System\Data\OleDb\OleDbDataReader.cs (1)

766override public Byte GetByte(int ordinal) {

fx\src\data\System\Data\OleDb\OleDbParameter.cs (8)

66Byte precision, Byte scale, 85Byte precision, Byte scale, 170[DefaultValue((Byte)0)] // MDAC 65862 173public new Byte Precision { 200[DefaultValue((Byte)0)] // MDAC 65862 203public new Byte Scale {

fx\src\data\System\Data\OleDb\OleDbStruct.cs (6)

51internal Byte bPrecision; 52internal Byte bScale; 165internal Byte bPrecision; 166internal Byte bScale; 358internal Byte bPrecision = 0; 360internal Byte bScale = 0;

fx\src\data\System\Data\OleDb\PropertyInfoSet.cs (1)

159case VarEnum.VT_UI1: return typeof(System.Byte);

fx\src\data\System\Data\ProviderBase\DbBuffer.cs (1)

671buffer[3] = (Byte) ((0 == buffer[3]) ? 1 : 0); // flip sign for native

fx\src\data\System\Data\Sql\SqlMetaData.cs (5)

1049case TypeCode.Byte: value = this.Adjust((Byte)value); break; 1066if (dataType == typeof(System.Byte[])) 1067value = this.Adjust((System.Byte[])value); 1166if (dataType == typeof(System.Byte[])) 1168long maxLen = ((System.Byte[])value).Length;

fx\src\data\System\Data\Sql\sqlnorm.cs (7)

358byte[] b = new Byte[2]; 380byte[] b = new Byte[2]; 404byte[] b = new Byte[4]; 448byte[] b = new Byte[8]; 472byte[] b = new Byte[8]; 508byte[] b = new Byte[4]; 555byte[] b = new Byte[8];

fx\src\data\System\Data\SqlClient\SqlBuffer.cs (8)

65internal Byte precision; 66internal Byte scale; 88[FieldOffset(0)] internal Byte _byte; 153internal Byte Byte { 160return (Byte)this.Value; // anything else we haven't thought of goes through boxing. 170internal Byte[] ByteArray { 763case SqlBuffer.StorageType.Byte: return typeof(Byte); 773case SqlBuffer.StorageType.SqlBinary: return typeof(Byte[]);

fx\src\data\System\Data\SqlClient\SqlDelegatedTransaction.cs (1)

137public Byte [] Promote() {

fx\src\data\System\Data\SqlClient\SqlDependency.cs (1)

1178if (type == typeof(Byte[])) {

fx\src\data\System\Data\SqlClient\SqlEnums.cs (9)

288if (dataType == typeof(System.Byte[])) { 500else if (comVal is System.Byte[]) 718(255, 255, -1, false, false, false, TdsEnums.SQLBIGBINARY, TdsEnums.SQLBIGBINARY, MetaTypeName.BINARY, typeof(System.Byte[]), typeof(SqlBinary), SqlDbType.Binary, DbType.Binary, 2); 722(255, 255, -1, false, false, false, TdsEnums.SQLBIGBINARY, TdsEnums.SQLBIGBINARY, MetaTypeName.TIMESTAMP, typeof(System.Byte[]), typeof(SqlBinary), SqlDbType.Timestamp, DbType.Binary, 2); 725(255, 255, -1, false, false, false, TdsEnums.SQLBIGVARBINARY, TdsEnums.SQLBIGVARBINARY, MetaTypeName.VARBINARY, typeof(System.Byte[]), typeof(SqlBinary), SqlDbType.VarBinary, DbType.Binary, 2); 728(255, 255, -1, false, true, true, TdsEnums.SQLBIGVARBINARY, TdsEnums.SQLBIGVARBINARY, MetaTypeName.VARBINARY, typeof(System.Byte[]), typeof(SqlBinary), SqlDbType.VarBinary, DbType.Binary, 2); 734(255, 255, -1, false, false, false, TdsEnums.SQLVARBINARY, TdsEnums.SQLBIGBINARY, ADP.StrEmpty, typeof(System.Byte[]), typeof(SqlBinary), TdsEnums.SmallVarBinary, DbType.Binary, 2); 737(255, 255, -1, false, true, false, TdsEnums.SQLIMAGE, TdsEnums.SQLIMAGE, MetaTypeName.IMAGE, typeof(System.Byte[]), typeof(SqlBinary), SqlDbType.Image, DbType.Binary, 0); 743(3, 255, 1, true, false, false, TdsEnums.SQLINT1, TdsEnums.SQLINTN, MetaTypeName.TINYINT, typeof(System.Byte), typeof(SqlByte), SqlDbType.TinyInt, DbType.Byte, 0);

fx\src\data\System\Data\SqlClient\sqlmetadatafactory.cs (2)

156Byte[] byteArrayValue = (Byte[])values[publicKeyIndex];

fx\src\data\System\Data\SqlClient\SqlParameter.cs (4)

556[DefaultValue((Byte)0)] // MDAC 65862 559public new Byte Precision { 593[DefaultValue((Byte)0)] // MDAC 65862 596public new Byte Scale {

fx\src\data\System\Data\SqlClient\TdsParser.cs (3)

1469stateObj._outBuff[1] = (Byte)(stateObj._outBuff[1] | TdsEnums.ST_RESET_CONNECTION_PRESERVE_TRANSACTION); 1473stateObj._outBuff[1] = (Byte)(stateObj._outBuff[1] | TdsEnums.ST_RESET_CONNECTION); 3692Debug.Assert(0 != codePage, "GetCodePage accessed codepage array and produced 0!, sortID =" + ((Byte)(collation.sortId)).ToString((IFormatProvider)null));

fx\src\data\System\Data\SqlClient\TdsParserStateObject.cs (2)

2725internal Task WriteByteArray(Byte[] b, int len, int offsetBuffer, bool canAccumulate=true, TaskCompletionSource<object> completion = null) { 2803private void WriteByteArraySetupContinuation(Byte[] b, int len, TaskCompletionSource<object> completion, int offset, Task packetTask) {

fx\src\data\System\Data\SqlClient\TdsParserStaticMethods.cs (5)

95static internal Byte[] EncryptPassword(string password) { 96Byte[] bEnc = new Byte[password.Length << 1]; 105bEnc[i<<1] = (Byte) ( (((bLo & 0x0f) << 4) | (bLo >> 4)) ^ 0xa5 ); 106bEnc[(i<<1)+1] = (Byte) ( (((bHi & 0x0f) << 4) | (bHi >> 4)) ^ 0xa5);

fx\src\data\System\Data\SqlClient\TdsRecordBufferSetter.cs (1)

92public override void SetByte(SmiEventSink sink, int ordinal, Byte value) {

fx\src\data\System\Data\SqlClient\TdsValueSetter.cs (1)

134internal void SetByte(Byte value) {

fx\src\data\System\Data\SQLTypes\SQLByte.cs (14)

120return new SqlByte(Byte.Parse(s, (IFormatProvider)null)); 258if (x.Value > (short)Byte.MaxValue || x.Value < (short)Byte.MinValue) 272if (x.Value > (int)Byte.MaxValue || x.Value < (int)Byte.MinValue) 286if (x.Value > (long)Byte.MaxValue || x.Value < (long)Byte.MinValue) 300if (x.Value > (float)Byte.MaxValue || x.Value < (float)Byte.MinValue) 314if (x.Value > (double)Byte.MaxValue || x.Value < (double)Byte.MinValue) 334return x.IsNull ? Null : new SqlByte(Byte.Parse(x.Value, (IFormatProvider)null)); 611public static readonly SqlByte MinValue = new SqlByte(Byte.MinValue); 615public static readonly SqlByte MaxValue = new SqlByte(Byte.MaxValue);

fx\src\data\System\Data\SQLTypes\UnsafeNativeMethods.cs (3)

290internal Byte flags; 291internal Byte EaNameLength; 293internal Byte EaName;

fx\src\data\System\Data\XDRSchema.cs (3)

216new NameType("bin.base64" , typeof(Byte[]) ), /* XDR */ 217new NameType("bin.hex" , typeof(Byte[]) ), /* XDR */ 246new NameType("ui1" , typeof(Byte) ), /* XDR */

fx\src\data\System\Data\xmlsaver.cs (2)

206if (type == typeof(Byte[]) || type == typeof(SqlBytes)) 224if (type == typeof(Byte))

fx\src\data\System\Data\XMLSchema.cs (3)

1569new NameType("base64Binary" , typeof(Byte[]) ), /* XSD Apr : abstruct */ 1583new NameType("hexBinary" , typeof(Byte[]) ), /* XSD Apr : abstruct */ 1596new NameType("unsignedByte" , typeof(Byte) ), /* XSD Apr */

System\Data\DataRowComparer.cs (3)

73return DataRowComparer.CompareEquatableArray<Byte>((Byte[])a, (Byte[])b);

System\Data\Common\EntitySql\AST\Literal.cs (1)

43private static readonly Byte[] _emptyByteArray = new byte[0];

System\Data\Common\EntitySql\SemanticAnalyzer.cs (1)

2458if (value.IsNumber && Byte.TryParse(value.OriginalValue, out byteValue))

System\Data\EntityModel\SchemaObjectModel\ByteFacetDescriptionElement.cs (1)

42DefaultValue = (Byte)value;

System\Data\EntityModel\SchemaObjectModel\ScalarType.cs (2)

130Byte temp; 131if (!Byte.TryParse(text, System.Globalization.NumberStyles.Integer, System.Globalization.CultureInfo.InvariantCulture, out temp))

System\Data\Mapping\Update\Internal\KeyManager.cs (6)

14using NodeColor = System.Byte; 29private const NodeColor White = 0; 30private const NodeColor Black = 1; 31private const NodeColor Gray = 2; 283var color = new NodeColor[_identifiers.Count]; 361private void ValidateReferentialIntegrityGraphAcyclic(int node, NodeColor[] color, LinkedList<int> parent)

System\Data\Mapping\Update\Internal\Propagator.ExtentPlaceholderCreator.cs (2)

56typeDefaultMap[PrimitiveTypeKind.Binary] = new Byte[0]; 58typeDefaultMap[PrimitiveTypeKind.Byte] = default(Byte);

System\Data\Metadata\Edm\EnumMember.cs (1)

51Debug.Assert(value is SByte || value is Byte || value is Int16 || value is Int32 || value is Int64, "Unsupported type of enum member value.");

System\Data\Metadata\Edm\Provider\ClrProviderManifest.cs (2)

206primitiveTypes[(int)PrimitiveTypeKind.Binary] = CreatePrimitiveType(typeof(Byte[]), PrimitiveTypeKind.Binary); 208primitiveTypes[(int)PrimitiveTypeKind.Byte] = CreatePrimitiveType(typeof(Byte), PrimitiveTypeKind.Byte);

System\Data\Metadata\Edm\Provider\EdmProviderManifest.cs (4)

35internal const byte MaximumDecimalPrecision = Byte.MaxValue; 36internal const byte MaximumDateTimePrecision = Byte.MaxValue; 157InitializePrimitiveType(primitiveTypes[(int)PrimitiveTypeKind.Binary], PrimitiveTypeKind.Binary, EdmConstants.Binary, typeof(Byte[])); 159InitializePrimitiveType(primitiveTypes[(int)PrimitiveTypeKind.Byte], PrimitiveTypeKind.Byte, EdmConstants.Byte, typeof(Byte));

System\Data\Metadata\Helper.cs (2)

517{ PrimitiveTypeKind.Byte, new long[] { Byte.MinValue, Byte.MaxValue } },

System\Data\Metadata\TypeHelpers.cs (1)

706if (clrType == typeof(System.Byte[]))

System\Data\Objects\DataClasses\StructuralObject.cs (4)

301protected internal static Byte[] SetValidValue(Byte[] value, bool isNullable, string propertyName) 329protected internal static Byte[] SetValidValue(Byte[] value, bool isNullable)

System\Data\Objects\SqlClient\SqlFunctions.cs (13)

90public static System.Int32? CharIndex(System.Byte[] toSearch, System.Byte[] target) 108public static System.Int32? CharIndex(System.Byte[] toSearch, System.Byte[] target, System.Int32? startLocation) 126public static System.Int64? CharIndex(System.Byte[] toSearch, System.Byte[] target, System.Int64? startLocation) 986public static System.Int32? DataLength(System.Byte[] arg) 1067public static System.Int32? Checksum(System.Byte[] arg1) 1148public static System.Int32? Checksum(System.Byte[] arg1, System.Byte[] arg2) 1229public static System.Int32? Checksum(System.Byte[] arg1, System.Byte[] arg2, System.Byte[] arg3)

System\Data\SqlClient\SqlGen\SqlGenerator.cs (3)

923result.Append(ByteArrayToBinaryString((Byte[])e.Value)); 970byte precision = (byte)Math.Max((Byte)strDecimal.Length, defaultDecimalPrecision); 4213private static string ByteArrayToBinaryString( Byte[] binaryArray )

System\Data\Services\Parsing\WebConvert.cs (3)

405else if (typeof(Byte) == targetType) 514else if (typeof(Byte) == targetType) 631else if (typeof(Byte) == valueType)

System\Data\Services\Serializers\JsonDeserializer.cs (1)

118else if (propertyType == typeof(Byte))

System\Data\Services\Serializers\JsonSerializer.cs (1)

333else if (typeof(Byte) == value.GetType())

System\Data\Services\WebUtil.cs (2)

72new KeyValuePair<Type, string>(typeof(Byte), XmlConstants.EdmByteTypeName), 73new KeyValuePair<Type, string>(typeof(Byte?), XmlConstants.EdmByteTypeName),

parent\Server\System\Data\Services\Parsing\WebConvert.cs (1)

631else if (typeof(Byte) == valueType)

System\Data\Services\Client\ClientConvert.cs (3)

464types[(int)StorageType.Byte] = typeof(Byte); 465types[(int)StorageType.ByteArray] = typeof(Byte[]); 501named.Add(XmlConstants.EdmByteTypeName, typeof(Byte));

System\Data\Services\Client\QueryResult.cs (1)

242Byte[] buffer = this.GetAsyncResponseStreamCopyBuffer();

commonui\System\Drawing\Advanced\EncoderParameter.cs (2)

103parameterValue = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(Byte))); 125parameterValue = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(Byte)));

System\IO\Log\FileLogRecordHeader.cs (1)

34this.bits = new Byte[Size];

Instrumentation\EventSource.cs (1)

486[In] ref Byte pSid)

Instrumentation\SchemaMapping.cs (2)

391 if(t2 == typeof(Byte) || t2 == typeof(SByte)) 518 else if(t2 == typeof(Byte))

InteropClasses\WMIInterop.cs (12)

50Byte[] rg = info.GetValue(SerializationBlobName, typeof(Byte[])) as Byte[]; 84void DeserializeFromBlob(Byte [] rg) 107Byte[] SerializeToBlob() 109Byte [] rg = null; 121rg = new Byte[statstg.cbSize]; 830[PreserveSig] int WritePropertyValue_([In] Int32 lHandle, [In] Int32 lNumBytes, [In] ref Byte aData); 831[PreserveSig] int ReadPropertyValue_([In] Int32 lHandle, [In] Int32 lBufferSize, [Out] out Int32 plNumBytes, [Out] out Byte aData); 969[PreserveSig] int AccessCheck_([In][MarshalAs(UnmanagedType.LPWStr)] string wszQueryLanguage, [In][MarshalAs(UnmanagedType.LPWStr)] string wszQuery, [In] Int32 lSidLength, [In] ref Byte pSid); 1059[PreserveSig] int IndicateWithSD_([In] Int32 lNumObjects, [In][MarshalAs(UnmanagedType.IUnknown)] ref object apObjects, [In] Int32 lSDLength, [In] ref Byte pSD); 1060[PreserveSig] int SetSinkSecurity_([In] Int32 lSDLength, [In] ref Byte pSD);

property.cs (8)

407 if (val is Byte[]) 411 wmiValue = new Byte [length]; 413 ((Byte[])wmiValue)[i] = Convert.ToByte(valArray.GetValue(i),(IFormatProvider)culInfo.GetFormat(typeof(System.Byte))); 543 wmiValue = Convert.ToByte(val,(IFormatProvider)culInfo.GetFormat(typeof(System.Byte))); 638 if (elementType == typeof(System.Byte)) 646 ((short[])wmiValue) [i] = ((IConvertible)((System.Byte)(arrayValue[i]))).ToInt16(null); 790 else if (valueType == typeof(System.Byte))

System\Numerics\BigInteger.cs (3)

536public BigInteger(Byte[] value) 1131public static implicit operator BigInteger(Byte value) 1191public static explicit operator Byte(BigInteger value)

System\Numerics\BigNumber.cs (4)

329Byte * numberBufferBytes = stackalloc Byte[Number.NumberBuffer.NumberBufferBytes]; 616Byte * numberBufferBytes = stackalloc Byte[Number.NumberBuffer.NumberBufferBytes];

System\Numerics\Complex.cs (1)

239public static implicit operator Complex(Byte value) {

metadata\sudscommon.cs (1)

75internal static Type typeofByte = typeof(Byte);

System\Runtime\Serialization\DataContract.cs (1)

742type = typeof(Byte);

System\ServiceModel\Channels\FramingEncoders.cs (1)

203(Byte)FramingRecordType.End

System\ServiceModel\Channels\UnsafeNativeMethods.cs (1)

1129private static extern Int32 _GetCurrentPackageId(ref Int32 pBufferLength, Byte[] pBuffer);

System\ServiceModel\ComIntegration\PersistStreamTypeWrapper.cs (3)

51byte[] byteArray = new Byte[sizeOfByteArray]; 73internal static Byte[] PersistIPersistStreamToByteArray(IPersistStream persistableObject) 97internal static void LoadIntoObjectFromByteArray(IPersistStream persistableObject, Byte[] byteStream)

System\Runtime\TypeHelper.cs (2)

346Byte byteSource = (Byte)source;

System\ServiceModel\Dispatcher\QueryStringConverter.cs (3)

30this.defaultSupportedQueryStringTypes.Add(typeof(Byte), null); 78return parameter == null ? default(Byte) : XmlConvert.ToByte(parameter); 177return XmlConvert.ToString((Byte) parameter);

System\Transactions\ITransactionPromoter.cs (1)

7Byte[] Promote();

System\Transactions\Oletx\OletxEnlistment.cs (1)

360this.proxyPrepareInfoByteArray = new Byte[arrayLength];

System\Transactions\TransactionState.cs (1)

5292Byte[] propagationToken = tx.promoter.Promote();

Configuration\CompilationSection.cs (1)

732Byte[] publicKeyToken = asmName.GetPublicKeyToken();

Handlers\AssemblyResourceLoader.cs (1)

567tokenBytes[i] = Byte.Parse(token.Substring(i * 2, 2), NumberStyles.HexNumber, CultureInfo.InvariantCulture);

Hosting\ApplicationManager.cs (1)

1345publicKey[i] = Byte.Parse(publicKeyString.Substring(i * 2, 2), System.Globalization.NumberStyles.HexNumber, CultureInfo.InvariantCulture);

Security\FormsAuthenticationTicket.cs (1)

156private Byte[] _InternalData;

State\SessionStateItemCollection.cs (2)

167t=typeof(Byte); 526buffer = new Byte[position.DataLength];

State\SessionStateUtil.cs (1)

152Byte eof;

UI\ObjectStateFormatter.cs (3)

121private const int StringTableSize = Byte.MaxValue; 730_stringList = new string[Byte.MaxValue]; 744_stringList = new string[Byte.MaxValue];

UI\WebControls\FileUpload.cs (1)

69Byte[] completeImage = null;

Util\altserialization.cs (1)

76else if (value is Byte) {

Common\DataManager\DataPoint.cs (2)

2066 else if(value is Byte) 2068 return (double)((Byte)value);

Common\DataManager\DataSeries.cs (1)

935 type == typeof(Byte) ||

WebForm\General\ChartHttpHandler.cs (13)

265Byte[] data = handler.Load(KeyToUnc(key)); 792void Save(String key, Byte[] data); 800Byte[] Load(String key); 1503void IChartStorageHandler.Save(String key, Byte[] data) 1557Byte[] IChartStorageHandler.Load( String key) 1562Byte[] data = new Byte[0]; 1587data = (Byte[])_storageData[key]; 1613byte[] privacyMarkerStream = new Byte[_privacyMarker.Length]; 1623byte[] privacyDataFromStream = new Byte[privacyData.Length]; 1649data = new Byte[(int)stream.Length - streamCut]; 1659data = (Byte[])HttpContext.Current.Session[GetSessionImageKey(key)]; 1725return HttpContext.Current.Session[GetSessionImageKey(key)] is Byte[];

DynamicData\DataSourceUtil.cs (2)

25typeNameToTypeCode[typeof(Byte)] = TypeCode.Byte; 40typeNameToTypeCode[typeof(Byte[])] = TypeCode.DBNull;

System\Data\WebControls\EntityDataSourceUtil.cs (2)

322return typeof(Byte); 395return typeof(Byte);

UI\WebControls\Dynamic.cs (1)

604typeof(Byte),

Util\HexParser.cs (1)

16tokenBytes[i] = Byte.Parse(token.Substring(i * 2, 2), NumberStyles.HexNumber, CultureInfo.InvariantCulture);

UI\MobileControls\Adapters\ChtmlTextBoxAdapter.cs (2)

64Byte[] randomBytes = new Byte[length];

UI\MobileControls\Adapters\WmlMobileTextWriter.cs (2)

1540Byte[] randomBytes = new Byte[length];

UI\MobileControls\Design\ImageDesigner.cs (1)

136Byte[] buffer = FileReader.Read(imageUri);

UI\MobileControls\Design\Util\FileReader.cs (3)

30internal static Byte[] Read(Uri uri) 35Byte[] buffer = null; 42buffer = new Byte[length];

UI\MobileControls\Design\Util\WbmpConverter.cs (3)

20private static int ExtractMultiByte(Byte[] buffer, ref int cursor) 32internal static Bitmap Convert(Byte[] buffer) 50Byte mask = 0x80;

winforms\Managed\System\WinForms\ComponentModel\COM2Interop\COM2TypeInfoProcessor.cs (1)

947return typeof(Byte);

winforms\Managed\System\WinForms\DataGridTable.cs (1)

1478dataType.Equals(typeof(Byte)) ||

Common\DataManager\DataPoint.cs (2)

2066 else if(value is Byte) 2068 return (double)((Byte)value);

Common\DataManager\DataSeries.cs (1)

935 type == typeof(Byte) ||

Common\TypeSystemHelpers.cs (1)

236thatToken[i] = Byte.Parse(partValue.Substring(i * 2, 2), NumberStyles.HexNumber, CultureInfo.InvariantCulture);

AuthoringOM\DependencyProperty.cs (1)

93internal static DependencyProperty FromKnown(Byte byteVal)

AuthoringOM\Design\ActivityDesignerLayoutSerializers.cs (4)

341return System.Drawing.Color.FromArgb((Byte)(propertyValue >> 24), (Byte)(propertyValue >> 16), (Byte)(propertyValue >> 8), (Byte)(propertyValue));

Shared\TypeSystemHelpers.cs (1)

235thatToken[i] = Byte.Parse(partValue.Substring(i * 2, 2), NumberStyles.HexNumber, CultureInfo.InvariantCulture);

Hosting\SqlWorkflowPersistenceService.cs (6)

36public Byte[] SerializedActivity; 211public void InsertCompletedScope(Guid instanceId, Guid scopeId, Byte[] state) 408public Byte[] RetrieveInstanceState(Guid instanceStateId, Guid ownerId, DateTime timeout) 478public Byte[] RetrieveCompletedScope(Guid scopeId) 598private static Byte[] RetrieveStateFromDB(DbCommand command, bool checkOwnership, Guid instanceId) 994item.SerializedActivity = new Byte[0];

Hosting\WorkflowPersistenceService.cs (3)

50Byte[] result; 71Array.Resize<Byte>(ref result, Convert.ToInt32(compressedStream.Length)); 77static protected Activity RestoreFromDefaultSerializedForm(Byte[] activityBytes, Activity outerActivity)

Tracking\SqlTrackingService.cs (3)

1432Byte[] data = null; 1454Byte[] data = null; 1768Byte[] data = null;

Tracking\SqlTrackingWorkflowInstance.cs (4)

276data = formatter.Deserialize(new MemoryStream((Byte[])reader[4])); 365userData = formatter.Deserialize(new MemoryStream((Byte[])reader[7])); 423data = formatter.Deserialize(new MemoryStream((Byte[])reader[4])); 504tmp = formatter.Deserialize(new MemoryStream((Byte[])reader[3]));

parent\parent\parent\parent\InternalApis\NDP_Common\inc\Win8Helpers.cs (1)

36Byte[] pBuffer);

System\Xml\BinaryXml\XmlBinaryReader.cs (2)

2888map[(int)BinXmlToken.SQL_TINYINT] = typeof(System.Byte); 2920Type TypeOfByteArray = typeof( System.Byte[] );

System\Xml\Schema\XmlValueConverter.cs (3)

357protected static readonly Type ByteArrayType = typeof(Byte[]); 831if (value < (int) Byte.MinValue || value > (int) Byte.MaxValue)

System\Xml\Serialization\CodeGenerator.cs (2)

1091new Type[] { typeof(Int32), typeof(Int32), typeof(Int32), typeof(Boolean), typeof(Byte) }, 1099Ldc((Byte)((bits[3] >> 16) & 0xFF)); // decimal location

System\Xml\Serialization\PrimitiveXmlSerializers.cs (3)

99WriteElementStringRaw(@"unsignedByte", @"", System.Xml.XmlConvert.ToString((System.Byte)((System.Byte)o))); 145WriteNullableStringLiteralRaw(@"base64Binary", @"", FromByteArrayBase64(((System.Byte[])o)));

System\Xml\XmlConvert.cs (5)

685public static string ToString(Byte value) { 963public static Byte ToByte (string s) { 964return Byte.Parse(s, NumberStyles.AllowLeadingWhite|NumberStyles.AllowTrailingWhite, NumberFormatInfo.InvariantInfo); 968internal static Exception TryToByte(string s, out Byte result) { 969if (!Byte.TryParse(s, NumberStyles.AllowLeadingWhite|NumberStyles.AllowTrailingWhite, NumberFormatInfo.InvariantInfo, out result)) {

Base\MS\Internal\IO\Packaging\Certificate.cs (3)

114Byte[] byteArray = new Byte[s.Length]; 131Byte[] byteArray = _certificate.GetRawCertData();

Base\MS\Internal\IO\Packaging\CompoundFile\InternalSafeNativeCompoundFileInterfaces.cs (2)

116void Read(Byte[] pv, int cb, out int pcbRead); 117void Write(Byte[] pv, int cb, out int pcbWritten);

Base\MS\Internal\IO\Packaging\CompoundFile\NativeCompoundFileAPIs.cs (2)

686void IStream.Read(Byte[] pv, int cb, out int pcbRead) 698void IStream.Write(Byte[] pv, int cb, out int pcbWritten)

Base\MS\Internal\IO\Packaging\CompoundFile\PrivateUnsafeNativeCompoundFileMethods.cs (6)

152[MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 2), Out] Byte[] pv, 163[MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 2)] Byte[] pv, 246[MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 2), Out] Byte[] pv, 251[MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 2)] Byte[] pv, 350void Read([MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 1), Out] Byte[] pv, int cb, out int pcbRead); 351void Write([MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 1)] Byte[] pv, int cb, out int pcbWritten);

Base\MS\Internal\IO\Packaging\CompoundFile\RightsManagementEncryptedStream.cs (1)

872private void RandomFillUp(Byte[] buffer, int offset, int count)

Base\MS\Internal\IO\Zip\ZipIOExtraFieldElement.cs (2)

114Byte[] tempBuffer = _data; 115_data = new Byte[size];

Base\System\IO\Packaging\CompoundFile\DataSpaceManager.cs (3)

409Byte[] _extraData; 411internal DataSpaceDefinition(ArrayList transformStack, Byte[] extraData) 425internal Byte[] ExtraData

Base\System\Windows\Markup\TypeConverterHelper.cs (3)

213else if (typeof(Byte).IsAssignableFrom(type)) 297else if (type == typeof(Byte)) 397else if (typeof(Byte).IsAssignableFrom(type))

Configuration\HttpWrapper.cs (22)

Configuration\HttpWrapper.cs (22)