UInt64

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

10754bamlType.DefaultConstructor = delegate() { return new System.UInt64(); };

microsoft\win32\oavariantlib.cs (1)

system\convert.cs (4)

128(RuntimeType)typeof(UInt64), 1407public static ulong ToUInt64(UInt64 value) { 1430return UInt64.Parse(value, CultureInfo.CurrentCulture); 1437return UInt64.Parse(value, NumberStyles.Integer, provider);

system\datetime.cs (36)

119private const UInt64 TicksMask = 0x3FFFFFFFFFFFFFFF; 120private const UInt64 FlagsMask = 0xC000000000000000; 121private const UInt64 LocalMask = 0x8000000000000000; 123private const UInt64 KindUnspecified = 0x0000000000000000; 124private const UInt64 KindUtc = 0x4000000000000000; 125private const UInt64 KindLocal = 0x8000000000000000; 126private const UInt64 KindLocalAmbiguousDst = 0xC000000000000000; 140private UInt64 dateData; 150dateData = (UInt64)ticks; 153private DateTime(UInt64 dateData) { 165this.dateData = ((UInt64)ticks | ((UInt64)kind << KindShift)); 174dateData = ((UInt64)ticks | (isAmbiguousDst ? KindLocalAmbiguousDst : KindLocal)); 181this.dateData = (UInt64) DateToTicks(year, month, day); 204this.dateData = (UInt64)(DateToTicks(year, month, day) + TimeToTicks(hour, minute, second)); 223this.dateData = ((UInt64)ticks | ((UInt64)kind << KindShift)); 241this.dateData = (UInt64)calendar.ToDateTime(year, month, day, hour, minute, second, 0).Ticks; 275this.dateData = (UInt64)ticks; 300this.dateData = ((UInt64)ticks | ((UInt64)kind << KindShift)); 325this.dateData = (UInt64)ticks; 360this.dateData = ((UInt64)ticks | ((UInt64)kind << KindShift)); 380UInt64 serializedDateData = 0; 404this.dateData = (UInt64)serializedTicks; 423private UInt64 InternalKind { 523return new DateTime((UInt64)(DateToTicks(y, m, d) + InternalTicks % TicksPerDay) | InternalKind); 545return new DateTime((UInt64)(ticks + value) | InternalKind); 750return new DateTime((UInt64)dateData); 846return new DateTime((UInt64)(ticks - ticks % TicksPerDay) | InternalKind); 1093return new DateTime( ((UInt64)(ticks + FileTimeOffset)) | KindUtc); 1210return new DateTime( ((UInt64)(ticks)) | KindUtc); 1342return new DateTime((UInt64)(ticks - valueTicks) | InternalKind); 1491return new DateTime((UInt64)(ticks + valueTicks) | d.InternalKind); 1500return new DateTime((UInt64)(ticks - valueTicks) | d.InternalKind);

system\decimal.cs (3)

629UInt64 n; 636n = ((UInt64)remainder << 32) | (UInt32) value.mid; 641n = ((UInt64)remainder << 32) | (UInt32) value.lo;

system\deployment\isolationinterop.cs (15)

1029UInt64 HashReference( 1034UInt64 HashDefinition( 1138UInt64 HashReference( 1143UInt64 HashDefinition( 1671[MarshalAs(UnmanagedType.U8)] public UInt64 SizeReclaimationLimit; 1672[MarshalAs(UnmanagedType.U8)] public UInt64 RuntimeLimit; 1813UInt64 ulonglongQuota, 1815ref UInt64 SizeSharedWithExternalDeployment, 1816ref UInt64 SizeConsumedByInputDeploymentArray 2068public UInt64 QueryChangeID(IDefinitionIdentity asm) 2070UInt64 ChangeId; 2253[In] UInt64 ulonglongQuota, 2255[Out, In] ref UInt64 SizeSharedWithExternalDeployment, 2256[Out, In] ref UInt64 SizeConsumedByInputDeploymentArray 2314UInt64 QueryChangeID(

system\diagnostics\eventing\eventprovider.cs (2)

739else if (data is UInt64) 742UInt64* ulongptr = (ulong*)dataBuffer;

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

6233if (type.IsEnum() && Enum.GetUnderlyingType(type) != typeof(UInt64) && Enum.GetUnderlyingType(type) != typeof(Int64))

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

206: TraceLoggingTypeInfo<UInt64> 216public override void WriteData(TraceLoggingDataCollector collector, ref UInt64 value) 518: TraceLoggingTypeInfo<UInt64[]> 528public override void WriteData(TraceLoggingDataCollector collector, ref UInt64[] value) 805collector.AddScalar(EnumHelper<UInt64>.Cast(value));

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

633else if (elementType == typeof(UInt64)) 699else if (underlyingType == typeof(UInt64)) 745else if (dataType == typeof(UInt64))

system\double.cs (2)

94return (*(UInt64*)(&d) & 0x8000000000000000) == 0x8000000000000000; 103return (*(UInt64*)(&d) & 0x7FFFFFFFFFFFFFFFL) > 0x7FF0000000000000L;

system\enum.cs (6)

115UInt64 result = (UInt64)value; 122UInt64 result = (UInt64)(Int64)value; 222result = (UInt64)Convert.ToInt64(value, CultureInfo.InvariantCulture); 932if (underlyingType == typeof(UInt64))

system\gc.cs (2)

136private static extern void _AddMemoryPressure(UInt64 bytesAllocated); 141private static extern void _RemoveMemoryPressure(UInt64 bytesAllocated);

system\internal.cs (2)

125new List<UInt64>(); 149SZArrayHelper<UInt64>(null);

system\io\unmanagedmemoryaccessor.cs (12)

75if (buffer.ByteLength < (UInt64)(offset + capacity)) { 494public UInt64 ReadUInt64(Int64 position) { 495int sizeOfType = sizeof(UInt64); 498UInt64 result; 510result = *((UInt64*)(pointer)); 569structure = _buffer.Read<T>((UInt64)(_offset + position)); 624_buffer.ReadArray<T>((UInt64)(_offset + position), array, offset, n); 986public void Write(Int64 position, UInt64 value) { 987int sizeOfType = sizeof(UInt64); 1000*((UInt64*)pointer) = value; 1053_buffer.Write<T>((UInt64)(_offset + position), structure); 1088_buffer.WriteArray<T>((UInt64)(_offset + position), array, offset, count);

system\number.cs (15)

399UInt64 passedValue = 0; 451private unsafe static Boolean HexNumberToUInt64(ref NumberBuffer number, ref UInt64 value) { 460UInt64 n = 0; 467UInt64 newN = n; 470newN += (UInt64)(*p - '0'); 474newN += (UInt64)((*p - 'A') + 10); 478newN += (UInt64)((*p - 'a') + 10); 544if ((UInt64)n > (0x7FFFFFFFFFFFFFFF / 10)) { 596private unsafe static Boolean NumberToUInt64(ref NumberBuffer number, ref UInt64 value) { 604UInt64 n = 0; 611UInt64 newN = n + (UInt64)(*p++ - '0'); 1001internal unsafe static UInt64 ParseUInt64(String value, NumberStyles options, NumberFormatInfo numfmt) { 1004UInt64 i = 0; 1175internal unsafe static Boolean TryParseUInt64(String s, NumberStyles style, NumberFormatInfo info, out UInt64 result) {

system\resources\resourcereader.cs (1)

631else if (type == typeof(UInt64))

system\resources\resourcewriter.cs (2)

551else if (type == typeof(UInt64)) 647writer.Write((UInt64) value);

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

780(typeof(TResult) == typeof(UInt64) && default(UInt64) == (UInt64)(object)result) ||

system\runtime\interopservices\safebuffer.cs (1)

87((UIntPtr) UInt32.MaxValue) : ((UIntPtr) UInt64.MaxValue);

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

82[FieldOffset(0)] internal UInt64 _ui8; 204*(UInt64*)this._typeUnion._unionTypes._byref = (UInt64)value; 472public UInt64 AsUi8 {

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

42new Tuple<Type, PropertyType>(typeof(UInt64), PropertyType.UInt64), 114public UInt64 GetUInt64() 116return CoerceScalarValue<UInt64>(PropertyType.UInt64); 260public UInt64[] GetUInt64Array() 262return CoerceArrayValue<UInt64>(PropertyType.UInt64Array); 468else if (typeof(T) == typeof(UInt64)) {

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

52UInt64 GetUInt64(); 106UInt64[] GetUInt64Array();

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

167} else if (varType==typeof(UInt64)) {

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

325array = new UInt64[length]; 506internal static Type typeofUInt64 = typeof(UInt64); 531internal static Type typeofUInt64Array = typeof(UInt64[]);

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

158internal void WriteUInt64(UInt64 value)

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

375internal UInt64 ReadUInt64()

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

847UInt64[] uint64A = null; 891uint64A = (UInt64[])array; 934uint64A[index] = UInt64.Parse(value, CultureInfo.InvariantCulture);

system\security\cryptography\des.cs (12)

87UInt64 key = QuadWordFromBigEndian(rgbOddParityKey); 102UInt64 key = QuadWordFromBigEndian(rgbOddParityKey); 129private static UInt64 QuadWordFromBigEndian(byte[] block) 131UInt64 x; 133(((UInt64)block[0]) << 56) | (((UInt64)block[1]) << 48) | 134(((UInt64)block[2]) << 40) | (((UInt64)block[3]) << 32) | 135(((UInt64)block[4]) << 24) | (((UInt64)block[5]) << 16) | 136(((UInt64)block[6]) << 8) | ((UInt64)block[7])

system\security\cryptography\sha384managed.cs (31)

25private UInt64[] _stateSHA384; 26private UInt64[] _W; 49_stateSHA384 = new UInt64[8]; 51_W = new UInt64[80]; 138fixed (UInt64* stateSHA384 = _stateSHA384) { 140fixed (UInt64* expandedBuffer = _W) { 220private readonly static UInt64[] _K = { 244private static unsafe void SHATransform (UInt64* expandedBuffer, UInt64* state, byte* block) 246UInt64 a, b, c, d, e, f, g, h; 247UInt64 aa, bb, cc, dd, ee, ff, hh, gg; 248UInt64 T1; 319private static UInt64 RotateRight(UInt64 x, int n) { 323private static UInt64 Ch(UInt64 x, UInt64 y, UInt64 z) { 327private static UInt64 Maj(UInt64 x, UInt64 y, UInt64 z) { 331private static UInt64 Sigma_0(UInt64 x) { 335private static UInt64 Sigma_1(UInt64 x) { 339private static UInt64 sigma_0(UInt64 x) { 343private static UInt64 sigma_1(UInt64 x) { 352private static unsafe void SHA384Expand (UInt64* x)

system\security\cryptography\sha512managed.cs (31)

25private UInt64[] _stateSHA512; 26private UInt64[] _W; 41_stateSHA512 = new UInt64[8]; 43_W = new UInt64[80]; 130fixed (UInt64* stateSHA512 = _stateSHA512) { 132fixed (UInt64* expandedBuffer = _W) { 213private readonly static UInt64[] _K = { 237private static unsafe void SHATransform (UInt64* expandedBuffer, UInt64* state, byte* block) 239UInt64 a, b, c, d, e, f, g, h; 240UInt64 aa, bb, cc, dd, ee, ff, hh, gg; 241UInt64 T1; 312private static UInt64 RotateRight(UInt64 x, int n) { 316private static UInt64 Ch(UInt64 x, UInt64 y, UInt64 z) { 320private static UInt64 Maj(UInt64 x, UInt64 y, UInt64 z) { 324private static UInt64 Sigma_0(UInt64 x) { 328private static UInt64 Sigma_1(UInt64 x) { 332private static UInt64 sigma_0(UInt64 x) { 336private static UInt64 sigma_1(UInt64 x) { 345private static unsafe void SHA512Expand (UInt64* x)

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

766internal unsafe static void QuadWordFromBigEndian (UInt64* x, int digits, byte* block) { 772(((UInt64)block[j]) << 56) | (((UInt64)block[j+1]) << 48) | 773(((UInt64)block[j+2]) << 40) | (((UInt64)block[j+3]) << 32) | 774(((UInt64)block[j+4]) << 24) | (((UInt64)block[j+5]) << 16) | 775(((UInt64)block[j+6]) << 8) | ((UInt64)block[j+7]) 781internal static void QuadWordToBigEndian (byte[] block, UInt64[] x, int digits) {

system\security\principal\windowsidentity.cs (2)

1521instanceClaims.Add( new Claim(windowsClaim.Name, Convert.ToString((UInt64)uintValues[item], CultureInfo.InvariantCulture), ClaimValueTypes.UInteger64, m_issuerName, m_issuerName, this, propertyValue, string.Empty)); 1532((UInt64)boolValues[item] == 0 ? Convert.ToString(false, CultureInfo.InvariantCulture) : Convert.ToString(true, CultureInfo.InvariantCulture)),

system\threading\Tasks\Task.cs (2)

7015private UInt64 m_lastKnownWatermark; 7080UInt64 current64 = currentAddr.ToUInt64();

system\uint64.cs (9)

30, IComparable<UInt64>, IEquatable<UInt64> 51if (value is UInt64) { 62public int CompareTo(UInt64 value) { 71if (!(obj is UInt64)) { 74return m_value == ((UInt64)obj).m_value; 78public bool Equals(UInt64 obj) 135public static Boolean TryParse(String s, out UInt64 result) { 140public static Boolean TryParse(String s, NumberStyles style, IFormatProvider provider, out UInt64 result) {

system\variant.cs (1)

102typeof(UInt64),

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

197else if (typeof(UInt64).IsAssignableFrom(type))

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

5494case KnownElements.UInt64: t = typeof(UInt64); break;

Core\CSharp\MS\Internal\Ink\InkSerializedFormat\SerializationHelper.cs (2)

269else if (typeof(UInt64) == type) 273else if (typeof(UInt64[]) == type)

Core\CSharp\System\Windows\Media\ColorTransform.cs (12)

232colorValue = (long)(((UInt64)channel[3] << 48) + ((UInt64)channel[2] << 32) + ((UInt64)channel[1] << 16) + (UInt64)channel[0]); 256colorValue = (long)(((UInt64)channel[7] << 56) + ((UInt64)channel[6] << 48) + 257((UInt64)channel[5] << 40) + ((UInt64)channel[4] << 32) + 258((UInt64)channel[3] << 24) + ((UInt64)channel[2] << 16) + 259((UInt64)channel[1] << 8) + ((UInt64)channel[0] << 0));

Core\CSharp\System\Windows\Media\GlyphRun.cs (1)

1923command.pIDWriteFont = (UInt64)_glyphTypeface.GetDWriteFontAddRef;

Core\CSharp\System\Windows\Media\Imaging\PropVariant.cs (9)

100[FieldOffset(8)] internal UInt64 ulVal; 329else if (type == typeof(UInt64[])) 331InitVector(value as Array, typeof(UInt64), VarEnum.VT_UI8); 420else if (type == typeof(UInt64)) 423ulVal = (UInt64)value; 612UInt64[] array = new UInt64[ca.cElems]; 614array[i] = (UInt64) Marshal.ReadInt64(ca.pElems, i*sizeof(UInt64));

Core\CSharp\System\Windows\Media\Imaging\WriteableBitmap.cs (2)

1442command.SwDoubleBufferedBitmap = (UInt64) _pDoubleBufferedBitmap.DangerousGetHandle().ToPointer(); 1542command.CopyCompletedEvent = (UInt64) hDuplicate.ToInt64();

Graphics\include\exports.cs (2)

2485command.hwnd = (UInt64)hWndUIntPtr; 2591command.pRenderTarget = (UInt64)pRenderTarget;

Graphics\include\Generated\wgx_commands.cs (12)

49[FieldOffset(4)] internal UInt64 FrameTime; 56[FieldOffset(8)] internal UInt64 pInteropDeviceBitmap; 57[FieldOffset(16)] internal UInt64 pSoftwareBitmap; 64[FieldOffset(8)] internal UInt64 hEvent; 314[FieldOffset(8)] internal UInt64 hwnd; 315[FieldOffset(16)] internal UInt64 hSection; 316[FieldOffset(24)] internal UInt64 masterDevice; 356[FieldOffset(8)] internal UInt64 hwnd; 357[FieldOffset(16)] internal UInt64 pRenderTarget; 404[FieldOffset(8)] internal UInt64 pIDWriteFont; 419[FieldOffset(8)] internal UInt64 SwDoubleBufferedBitmap; 427[FieldOffset(8)] internal UInt64 CopyCompletedEvent;

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

539typeof(UInt32), typeof(UInt64), typeof(UInt16), typeof(SByte), // non-CLS compliant types 546typeof(UInt32), typeof(UInt64), typeof(UInt16), typeof(SByte), // non-CLS compliant types

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

791case 699: t = () => typeof(UInt64); break;

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

10752typeof(System.UInt64),

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

6243case KnownElements.UInt64: t = typeof(System.UInt64); break;

src\Framework\System\Windows\Window.cs (1)

6891var intValue = (ulong)(taskbarInfo.ProgressValue * precisionValue);

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

1206else if (e.Value is UInt64) { 1207Output.Write(((UInt64)e.Value).ToString(CultureInfo.InvariantCulture));

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

1077else if (e.Value is UInt64) { 1078Output.Write(((UInt64)e.Value).ToString(CultureInfo.InvariantCulture));

compmod\system\componentmodel\ReflectTypeDescriptionProvider.cs (6)

131temp[typeof(UInt64)] = typeof(UInt64Converter); 613UInt64 canExtend = 0; 645canExtend |= (UInt64)1 << curIdx; 662canExtend |= (UInt64)1<<curIdx; 690if ((curIdx < maxCanExtendResults && (canExtend & ((UInt64)1 << curIdx)) != 0 )|| 707if (p != null && ((curIdx < maxCanExtendResults && (canExtend & ((UInt64)1 << curIdx)) != 0) ||

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

34return typeof(UInt64); 49return UInt64.Parse(value, NumberStyles.Integer, formatInfo); 57return UInt64.Parse(value, culture); 64return ((UInt64)value).ToString("G", formatInfo);

net\System\Net\NetworkInformation\UnSafeNetInfoNativemethods.cs (24)

System\Activities\Debugger\DebugInfo.cs (1)

367else if (t == typeof(UInt64))

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

243UInt64 Valid = B.ReadUInt64(); 244UInt64 Sorted = B.ReadUInt64(); 247UInt64 VBit = 1UL;

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

99return new TypeInfo(typeof(UInt64));

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

658public RemoteArgument(System.UInt64 value) 667public RemoteArgument(System.UInt64 value, bool isByRef) 1375public System.UInt64 UInt64Value 1383return default(System.UInt64); 1389return (System.UInt64)this._value;

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

525if (type == typeof(UInt64)) {

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

76case TypeCode.UInt64: return new PrimitiveParameterExpression<UInt64>(name);

Microsoft\Win32\UnsafeNativeMethods.cs (2)

753public UInt64 ULong; 775public UInt64 FileTime;

System\Diagnostics\Eventing\EventProvider.cs (2)

354else if (data is UInt64) 357UInt64* ulongptr = (ulong*)dataBuffer;

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

1245return ConvertToArray (val,typeof(UInt64), sizeof(UInt64));

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

109ht.Add( typeof( System.UInt64 ), ExtendedClrTypeCode.UInt64 );

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

855col.DataType == typeof(Int64) || col.DataType == typeof(UInt64)

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

43typeof(UInt64),

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

67else if (value.GetType() == typeof(UInt64)) { return (BigInteger)(UInt64)value; } 83else if (type == typeof(UInt64)) { return checked((UInt64)value); }

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

31UInt64 sum = defaultValue;

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

83typeof(UInt64),

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

238else if (valType == typeof(UInt64)){ 239values[recordNo] = BitConverter.GetBytes((UInt64)value);

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

136return (UInt64) value; 184return (UInt64) value; 226return (UInt64) value; 270return (UInt64) value; 514return ((IConvertible)(UInt64)value).ToString(formatProvider); 761return XmlConvert.ToString((UInt64) value);

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

31UInt64 sum = defaultValue;

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

31UInt64 sum = defaultValue; 34checked { sum += (UInt64) values[record];}

fx\src\data\System\Data\Common\UInt64Storage.cs (24)

18private const UInt64 defaultValue = UInt64.MinValue; 20private UInt64[] values; 23: base(column, typeof(UInt64), defaultValue, StorageType.UInt64) { 31UInt64 sum = defaultValue; 54UInt64 mean; 55checked {mean = (UInt64)(Decimal)(meanSum / (Decimal)meanCount);} 97UInt64 min = UInt64.MaxValue; 111UInt64 max = UInt64.MinValue; 136throw ExprException.Overflow(typeof(UInt64)); 142UInt64 valueNo1 = values[recordNo1]; 143UInt64 valueNo2 = values[recordNo2]; 162UInt64 valueNo1 = values[recordNo]; 166return valueNo1.CompareTo((UInt64)value); 188UInt64 value = values[record]; 208UInt64[] newValues = new UInt64[capacity]; 221return XmlConvert.ToString((UInt64)value); 225return new UInt64[recordCount]; 229UInt64[] typedStore = (UInt64[]) store; 235values = (UInt64[]) store;

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

487Value_UI8((UInt64) value); 1040internal UInt64 Value_UI8() { 1043return unchecked((UInt64) RowBinding.ReadInt64(ValueOffset)); 1045private void Value_UI8(UInt64 value) {

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

163case VarEnum.VT_UI8: return typeof(System.UInt64);

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

3637if (!_stateObj.Parser.TrySkipPlpValue(UInt64.MaxValue, _stateObj, out ignored)) {

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

359public const UInt64 UDTNULL = 0xffffffffffffffff;

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

3801if (!TrySkipPlpValue(UInt64.MaxValue, stateObj, out ignored)) { 4917if (!TrySkipPlpValue(UInt64.MaxValue, stateObj, out ignored)) {

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

249new NameType("ui8" , typeof(UInt64) ), /* XDR */

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

236if (type == typeof(UInt64))

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

1589new NameType("nonNegativeInteger" , typeof(UInt64) ), /* XSD Apr */ 1592new NameType("positiveInteger" , typeof(UInt64) ), /* XSD Apr */ 1598new NameType("unsignedLong" , typeof(UInt64) ), /* XSD Apr */

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

289UInt64 value; 290if (!UInt64.TryParse(numberPart, NumberStyles.Integer, CultureInfo.InvariantCulture, out value))

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

1371protected internal static UInt64 SetValidValue(UInt64 value, string propertyName) 1388protected internal static UInt64 SetValidValue(UInt64 value) 1407protected internal static Nullable<UInt64> SetValidValue(Nullable<UInt64> value, string propertyName) 1424protected internal static Nullable<UInt64> SetValidValue(Nullable<UInt64> value)

System\Data\Objects\Internal\EntityProxyFactory.cs (1)

1255propertyType == typeof(UInt64)||

SqlClient\Query\SqlMethodCallConverter.cs (1)

2421targetType = typeof(UInt64);

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

347return XmlConvert.ToString((UInt64)propertyValue); 483types[(int)StorageType.UInt64] = typeof(UInt64);

System\Xml\Xsl\XsltOld\Processor.cs (1)

216parameter is Int64 || parameter is UInt64 ||

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

492if (this.newBaseLsn != UInt64.MaxValue)

System\IO\Log\SequenceNumber.cs (4)

46if (value == UInt64.MaxValue) 48this.sequenceNumberLow = UInt64.MaxValue; 69return new SequenceNumber(UInt64.MaxValue, UInt64.MaxValue);

Instrumentation\SchemaMapping.cs (2)

411 else if(t2 == typeof(UInt64) || t2 == typeof(Int64) || t2 == typeof(Double)) 530 else if(t2 == typeof(UInt64))

InteropClasses\WMIInterop.cs (4)

834[PreserveSig] int ReadQWORD_([In] Int32 lHandle, [Out] out UInt64 pqw); 835[PreserveSig] int WriteQWORD_([In] Int32 lHandle, [In] UInt64 pw); 1080[PreserveSig] int GetInfo_([In] UInt32 uRequestedInfo, [Out] out UInt64 puResponse); 1091[PreserveSig] int GetInfo_([In] UInt32 uRequestedInfo, [Out] out UInt64 puResponse);

property.cs (14)

WmiGenerator.cs (4)

1889Int64 test = System.Convert.ToInt64(ValueMap[i],(IFormatProvider)CultureInfo.InvariantCulture.GetFormat(typeof(System.UInt64))); 1897typeof(System.UInt64))) == 0) 1993Int64 test = System.Convert.ToInt64(BitMap[i],(IFormatProvider)CultureInfo.InvariantCulture.GetFormat(typeof(System.UInt64))); 2009if( (System.Convert.ToInt64(BitMap[i],(IFormatProvider)CultureInfo.InvariantCulture.GetFormat(typeof(System.UInt64))) == 0) ) // Bug No: 121987

System\Messaging\ActiveXMessageFormatter.cs (2)

372else if (obj is UInt64) 375byte[] bytes = BitConverter.GetBytes((UInt64)obj);

System\Numerics\BigInteger.cs (16)

System\Numerics\Complex.cs (1)

232public static implicit operator Complex(UInt64 value) {

metadata\sudscommon.cs (1)

87internal static Type typeofUInt64 = typeof(UInt64);

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

754type = typeof(UInt64);

System\Runtime\Serialization\Json\JsonReaderDelegator.cs (1)

337internal override UInt64 ReadElementContentAsUnsignedLong()

System\Runtime\Serialization\XmlReaderDelegator.cs (2)

652internal virtual UInt64 ReadElementContentAsUnsignedLong() 666internal virtual UInt64 ReadContentAsUnsignedLong()

System\Xml\XmlBinaryWriter.cs (1)

529public override void WriteUInt64Text(UInt64 value)

System\Xml\XmlConverter.cs (6)

339static public UInt64 ToUInt64(string value) 359static public UInt64 ToUInt64(byte[] buffer, int offset, int count) 422static public string ToString(UInt64 value) { return value.ToString(NumberFormatInfo.InvariantInfo); } 449else if (value is UInt64) 450return ToString((UInt64)value); 1024static public int ToChars(UInt64 value, byte[] buffer, int offset)

System\Xml\XmlNodeWriter.cs (2)

90public abstract void WriteUInt64Text(UInt64 value); 136public override void WriteUInt64Text(UInt64 value) { }

System\Xml\XmlSigningNodeWriter.cs (1)

241public override void WriteUInt64Text(UInt64 value)

System\ServiceModel\Channels\ReliableDuplexSessionChannel.cs (2)

18UInt64 ackVersion = 1; 343UInt64 oldAckVersion = 0;

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

741UInt64 milliseconds = Convert.ToUInt64(timeSpan.TotalMilliseconds);

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

248UInt64 milliseconds = 0;

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

562if (!UInt64.TryParse(maxMessageNumberString, out maxMessageNumber)

System\ServiceModel\MsmqIntegration\ActiveXSerializer.cs (2)

365else if (obj is UInt64) 368byte[] bytes = BitConverter.GetBytes((UInt64)obj);

System\Runtime\Diagnostics\DiagnosticEventProvider.cs (2)

286else if (data is UInt64) 289UInt64* ulongptr = (ulong*)dataBuffer;

System\Runtime\Diagnostics\EtwProvider.cs (12)

System\Runtime\Interop\UnsafeNativeMethods.cs (1)

33internal UInt64 DataPointer;

System\Runtime\TypeHelper.cs (6)

365result = (T)(object)(UInt64)byteSource; 417result = (T)(object)(UInt64)uint16Source; 463result = (T)(object)(UInt64)uint32Source; 496UInt64 uint64Source = (UInt64)source; 529result = (T)(object)(UInt64)charSource;

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

37this.defaultSupportedQueryStringTypes.Add(typeof(UInt64), null); 101return parameter == null ? default(UInt64) : XmlConvert.ToUInt64(parameter); 200return XmlConvert.ToString((UInt64) parameter);

Security\AuthStoreRoleProvider.cs (1)

694args[0] = ( UInt64 )token;

State\SessionStateItemCollection.cs (1)

185t=typeof(UInt64);

UI\PropertyMapper.cs (1)

119(type == typeof(UInt64)) ||

Util\altserialization.cs (3)

112else if (value is UInt64) { 114writer.Write((UInt64) value); 145writer.Write((UInt64)v.ToUInt64());

Common\DataManager\DataPoint.cs (3)

1530 else if(columnDataType == typeof(UInt64)) 2062 else if(value is UInt64) 2064 return (double)((UInt64)value);

Common\DataManager\DataSeries.cs (1)

934 type == typeof(UInt64) ||

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

370return typeof(UInt64); 423return typeof(UInt64);

Script\Serialization\JavaScriptSerializer.cs (1)

483if ((underlyingType == typeof(Int64)) || (underlyingType == typeof(UInt64))) {

UI\WebControls\Dynamic.cs (2)

610typeof(UInt64), 961if (!UInt64.TryParse(text, out value))

System\Web\Services\Protocols\Scalars.cs (1)

73type == typeof(UInt64) ||

parent\parent\parent\public\Internal\NDP\Inc\IsolationInterop.cs (15)

1041UInt64 HashReference( 1046UInt64 HashDefinition( 1150UInt64 HashReference( 1155UInt64 HashDefinition( 1686[MarshalAs(UnmanagedType.U8)] public UInt64 SizeReclaimationLimit; 1687[MarshalAs(UnmanagedType.U8)] public UInt64 RuntimeLimit; 1829UInt64 ulonglongQuota, 1831ref UInt64 SizeSharedWithExternalDeployment, 1832ref UInt64 SizeConsumedByInputDeploymentArray 2084public UInt64 QueryChangeID(IDefinitionIdentity asm) 2086UInt64 ChangeId; 2269[In] UInt64 ulonglongQuota, 2271[Out, In] ref UInt64 SizeSharedWithExternalDeployment, 2272[Out, In] ref UInt64 SizeConsumedByInputDeploymentArray 2330UInt64 QueryChangeID(

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

966return typeof(UInt64);

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

1474dataType.Equals(typeof(UInt64)) ||

winforms\Managed\System\WinForms\NativeMethods.cs (2)

4365else if (t == typeof(UInt64)) { 4468return (UInt64)longVal;

Common\DataManager\DataPoint.cs (3)

1530 else if(columnDataType == typeof(UInt64)) 2062 else if(value is UInt64) 2064 return (double)((UInt64)value);

Common\DataManager\DataSeries.cs (1)

934 type == typeof(UInt64) ||

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

2896map[(int)BinXmlToken.XSD_UNSIGNEDLONG] = typeof(UInt64); 3935UInt64 GetUInt64(int pos) { 3939return (UInt64)((ulong)hi) << 32 | lo;

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

824if (value < (decimal) UInt64.MinValue || value > (decimal) UInt64.MaxValue)

System\Xml\Serialization\CodeExporter.cs (1)

290else if (type == typeof(UInt64)) {

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

135WriteElementStringRaw(@"unsignedLong", @"", System.Xml.XmlConvert.ToString((System.UInt64)((System.UInt64)o)));

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

466AddPrimitive(typeof(UInt64), "unsignedLong", "UInt64", TypeFlags.CanBeAttributeValue | TypeFlags.CanBeElementValue | TypeFlags.XmlEncodingNotRequired); 562AddSoapEncodedPrimitive(typeof(UInt64), "unsignedLong", ns, "UInt64", new XmlQualifiedName("string", XmlSchema.Namespace), TypeFlags.CanBeAttributeValue | TypeFlags.CanBeElementValue | TypeFlags.XmlEncodingNotRequired);

System\Xml\Serialization\XmlCodeExporter.cs (1)

243type == typeof(UInt64)) {

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

354return typeof(UInt64); 417return typeof(UInt64); 744value = default(Nullable<UInt64>);

System\Xml\Serialization\XmlSerializationWriter.cs (1)

288value = XmlConvert.ToString((UInt64)o);

System\Xml\XmlConvert.cs (5)

712public static string ToString(UInt64 value) { 1018public static UInt64 ToUInt64 (string s) { 1019return UInt64.Parse(s, NumberStyles.AllowLeadingWhite|NumberStyles.AllowTrailingWhite, NumberFormatInfo.InvariantInfo); 1023internal static Exception TryToUInt64(string s, out UInt64 result) { 1024if (!UInt64.TryParse(s, NumberStyles.AllowLeadingWhite|NumberStyles.AllowTrailingWhite, NumberFormatInfo.InvariantInfo, out result)) {

System\Xml\XPath\Internal\ExtensionQuery.cs (2)

104if (value is UInt64) return (double)(UInt64)value;

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

151UInt64 offset, 162UInt64 offset, 185void UnsafeNativeILockBytes.SetSize( UInt64 cb ) 192UInt64 libOffset, 193UInt64 cb, 201UInt64 libOffset, 202UInt64 cb, 245UInt64 offset, 250UInt64 offset, 255void SetSize( UInt64 cb ); 257UInt64 libOffset, 258UInt64 cb, 261UInt64 libOffset, 262UInt64 cb,

Base\MS\Internal\IO\Packaging\OlePropertyStructs.cs (1)

226internal UInt64 uhVal;

Base\MS\Internal\IO\Zip\ZipIOBlockManager.cs (5)

613internal static int CopyBytes(UInt64 value, byte[] buffer, int offset) 615Debug.Assert(checked(buffer.Length-offset) >= sizeof(UInt64)); 623internal static UInt64 ConvertToUInt64(UInt32 loverAddressValue, UInt32 higherAddressValue) 625return checked((UInt64)loverAddressValue + (((UInt64)higherAddressValue) << 32));

Base\MS\Internal\IO\Zip\ZipIOExtraFieldZip64Element.cs (15)

67if (size < sizeof(UInt64)) 72size -= sizeof(UInt64); 79if (size < sizeof(UInt64)) 84size -= sizeof(UInt64); 91if (size < sizeof(UInt64)) 96size -= sizeof(UInt64); 183size += sizeof(UInt64); 188size += sizeof(UInt64); 193size += sizeof(UInt64); 233_uncompressedSize = (UInt64)value; 250_compressedSize = (UInt64)value; 267_offsetOfLocalHeader = (UInt64)value; 335private UInt64 _uncompressedSize; 336private UInt64 _compressedSize; 337private UInt64 _offsetOfLocalHeader;

Base\MS\Internal\IO\Zip\ZipIOLocalFileDataDescriptor.cs (6)

160writer.Write((UInt64)_compressedSize); // 8 bytes 161writer.Write((UInt64)_uncompressedSize); // 8 bytes 219UInt64 suspectCompressedSize, 220UInt64 suspectUncompressedSize) 228((UInt64) compressedSizeFromCentralDir == suspectCompressedSize) && 229((UInt64) uncompressedSizeFromCentralDir == suspectUncompressedSize) &&

Base\MS\Internal\IO\Zip\ZipIOZip64EndOfCentralDirectoryBlock.cs (11)

130UInt64 centralDirCount = (UInt64)_blockManager.CentralDirectoryBlock.Count; 131UInt64 centralDirBlockSize = (UInt64)_blockManager.CentralDirectoryBlock.Size; 132UInt64 centralDirOffset = (UInt64)_blockManager.CentralDirectoryBlock.Offset; 435private UInt64 _sizeOfZip64EndOfCentralDirectory = _fixedMinimalValueOfSizeOfZip64EOCD; 440private UInt64 _totalNumberOfEntriesInTheCentralDirectoryOnThisDisk; // all int64s declared as signed values 441private UInt64 _totalNumberOfEntriesInTheCentralDirectory; // as we can not suport true unsigned 64 bit sizes 442private UInt64 _sizeOfTheCentralDirectory; // as a result of limitations in Stream interface 443private UInt64 _offsetOfStartOfCentralDirectoryWithRespectToTheStartingDiskNumber;

Base\MS\Internal\IO\Zip\ZipIOZip64EndOfCentralDirectoryLocatorBlock.cs (4)

118UInt64 offsetOfStartOfZip64EndOfCentralDirectoryRecord = 119(UInt64)_blockManager.Zip64EndOfCentralDirectoryBlock.Offset; 261if ((UInt64)_offset <= _offsetOfStartOfZip64EndOfCentralDirectoryRecord) // we assume that _offset >=0 285private UInt64 _offsetOfStartOfZip64EndOfCentralDirectoryRecord;

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

197else if (typeof(UInt64).IsAssignableFrom(type)) 281else if (type == typeof(UInt64)) 381else if (typeof(UInt64).IsAssignableFrom(type))

Shared\MS\Internal\DoubleUtil.cs (3)

295[FieldOffset(0)] internal UInt64 UintValue; 308UInt64 exp = t.UintValue & 0xfff0000000000000; 309UInt64 man = t.UintValue & 0x000fffffffffffff;

Shared\MS\Utility\TraceProvider.cs (1)

324else if (data is UInt64)

Shared\MS\Win32\NativeMethodsCLR.cs (1)

4780return (UInt64)longVal;

Shared\MS\Win32\UnsafeNativeMethodsEventTrace.cs (2)

146public UInt64 HistoricalContext; 147public UInt64 TimeStamp;