C# System.UInt64类代码示例

 public object WithRefsWithReturn(
     ref string param1,
     ref int param2,
     ref short param3,
     ref long param4,
     ref uint param5,
     ref ushort param6,
     ref ulong param7,
     ref bool param8,
     ref double param9,
     ref decimal param10,
     ref int? param11,
     ref object param12,
     ref char param13,
     ref DateTime param14,
     ref Single param15,
     ref IntPtr param16,
     ref UInt16 param17,
     ref UInt32 param18,
     ref UInt64 param19,
     ref UIntPtr param20
     )
 {
     throw new Exception("Foo");
 }

        public ValueVersion(UInt64 ve, string ss, byte[] va, int ec, ProcessStatus status, Int64 start, Int64 stop)
        {
            version = ve;
            shortStatus = ss;
            value = va;
            exitCode = ec;
            startTime = start;
            stopTime = stop;
            switch (status)
            {
                case ProcessStatus.Queued:
                    processStatus = "Queued";
                    break;

                case ProcessStatus.Running:
                    processStatus = "Running";
                    break;

                case ProcessStatus.Canceling:
                    processStatus = "Canceling";
                    break;

                default:
                    processStatus = "Completed";
                    break;
            }
        }

 /**
  * @since 3.0
  */
 public DistortionData(UInt64 version, float width, float height, float[] data)
 {
   Version = version;
   Width = width;
   Height = height;
   Data = data;
 }

        // Initialize *this for looking up user_key at a snapshot with
        // the specified sequence number.
        public LookupKey(Slice user_key, UInt64 sequence)
        {
            int usize = user_key.Size;
            int needed = usize + 13;  // A conservative estimate
            ByteArrayPointer dst;

            if (needed <= space_.Length)
            {
                dst = new ByteArrayPointer(space_);
            }
            else
            {
                dst = new ByteArrayPointer(needed);
            }

            start_ = dst;
            dst = Coding.EncodeVarint32(dst, (uint)(usize + 8));
            kstart_ = dst;

            user_key.Data.CopyTo(dst, usize);

            dst += usize;

            Coding.EncodeFixed64(dst, Global.PackSequenceAndType(sequence ,Global.kValueTypeForSeek));
            end_ = dst + 8;
        }

		/// <summary>
		/// Reverses the bytes.
		/// </summary>
		/// <returns>The bytes.</returns>
		/// <param name="value">Value.</param>
		private static UInt64 ReverseBytes(UInt64 value)
		{
			return (value & 0x00000000000000FFUL) << 56 | (value & 0x000000000000FF00UL) << 40 |
				(value & 0x0000000000FF0000UL) << 24 | (value & 0x00000000FF000000UL) << 8 |
				(value & 0x000000FF00000000UL) >> 8 | (value & 0x0000FF0000000000UL) >> 24 |
				(value & 0x00FF000000000000UL) >> 40 | (value & 0xFF00000000000000UL) >> 56;
		}

 public WebSocketBinaryFrame(byte[] data, UInt64 pos, UInt64 length, bool isFinal)
 {
     this.Data = data;
     this.Pos = pos;
     this.Length = length;
     this.IsFinal = isFinal;
 }

 public SftpWriteRequest(uint requestId, byte[] handle, UInt64 offset, byte[] data, Action<SftpStatusResponse> statusAction)
     : base(requestId, statusAction)
 {
     this.Handle = handle;
     this.Offset = offset;
     this.Data = data;
 }

 internal static object AddImpl(UInt64 left, UInt64 right)
 {
     if (left > UInt64.MaxValue - right) {
         return BigInteger.Create(left) + BigInteger.Create(right);
     }
     return left + right;
 }

 public ArpGenericData(UInt64 destinationEthernetAddress, ArpOperation arpOperation, UInt64 targetPhysicalAddress, UInt32 targetProtocolAddress)
 {
     this.DestinationEthernetAddress = destinationEthernetAddress;
     this.ArpOperaton = arpOperation;
     this.TargetPhysicalAddress = targetPhysicalAddress;
     this.TargetProtocolAddress = targetProtocolAddress;
 }

        internal static Tweak EncodeTweak(UInt64 position, bool bitPad, TweakType type, bool first, bool final)
        {
            //
            // Takes tweak parameters and encodes them in a 128 bit value. The lower half of the 128 byte value (only the position)
            // is stuck in low64 and the high half in stuck in high64.
            //
            // N.B SimpleSkeinManaged specifies that position can be upto 2^96 but we support only 2^64. We could add support by rolling our own BigInteger
            //
            // The encoding is as follows (ASCII art not to scale)
            //
            // 128             120                   112            96                                    0
            // --------------------------------------------------------------------------------------------
            // F1|F2|    Type   |B|       TreeLevel   |   reserved  |      Position                       |
            //   |  |           | |                   |             |                                     |
            // --------------------------------------------------------------------------------------------
            //  F1 = First
            //  F2 = Final
            //  B  - BitPad
            //

            Tweak tweak = new Tweak(0,0);
            tweak.high64 = 0;

            //
            // The shift numbers are calculated using 64 - (128 - end-byte-from-diagram-above)
            //
            if (final) tweak.high64 |= (UInt64)1L << 63; // Set F1 in diagram above
            if (first) tweak.high64 |= (UInt64)1L << 62; // Set F2 in diagram above
            tweak.high64 |= (UInt64)type << 56; // Set type
            if (bitPad) tweak.high64 |= (UInt64)1L << 55; // Set bit pad

            tweak.low64 = position;
            return tweak;
        }

 /// <summary>
 /// Compute the fingerprint
 /// </summary>
 /// <param name="source">String to compute</param>
 /// <returns>Hash key</returns>
 public static UInt64 ComputeFingerPrint(string source)
 {
     byte[] table = Encoding.Unicode.GetBytes(source);
     UInt64[] values = new UInt64[table.LongLength];
     ConvertBytes(ref table, ref values);
     return Compute(values);
 }

        public void onRemoveAvatar(UInt64 dbid)
        {
            Dbg.DEBUG_MSG("Account::onRemoveAvatar: dbid=" + dbid);

            avatars.Remove(dbid);
            Event.fire("onRemoveAvatar", new object[]{dbid});
        }

 public static string getAssignDepartmentToDoctorQuery(UInt64 departmentID, UInt64 doctorID)
 {
     StringBuilder query = new StringBuilder();
     query.Append("Insert into doctors(dr_id, dept_id) values(").Append(doctorID).Append(", ");
     query.Append(departmentID).Append(")");
     return query.ToString();
 }

 public PackageMissingException(string name, string arch, UInt64 version, string publicKeyToken)
 {
     Name = name;
     Arch = arch;
     Version = version;
     PublicKeyToken = publicKeyToken;
 }

 public Result(UInt64 number, UInt64 skip, UInt64 first, bool includeTotalCount)
 {
     this._number = number;
     this._skip = skip;
     this._first = first;
     this._includeTotalCount = includeTotalCount;
 }