public Document(
     Int16 _TypeId,
     Int64 _Serial,
     Int32 _SignedUser,
     DateTime _Date,
     Boolean _Printed,
     String _DocumentShortName,
     String _DocumentFullName,
     String _MedexDataTable,
     String _DocumentBody,
     String _DocumentHeader,
     Boolean _SetDeleted
     
     )
 {
     TypeId = _TypeId;
        Serial = _Serial;
        SignedUser = _SignedUser;
        Date = _Date;
        Printed = _Printed;
        DocumentShortName = _DocumentShortName;
        DocumentFullName = _DocumentFullName;
        MedexDataTable = _MedexDataTable;
        DocumentBody = _DocumentBody;
        DocumentHeader = _DocumentHeader;
        SetDeleted = _SetDeleted;
 }

 public MessageAttemptInfo(Message message, Int64 sequenceNumber, int retryCount, object state)
 {
     this.message = message;
     this.sequenceNumber = sequenceNumber;
     this.retryCount = retryCount;
     this.state = state;
 }

 internal static IsolatedStorageSecurityState CreateStateToIncreaseQuotaForApplication(Int64 newQuota, Int64 usedSize) { 
     IsolatedStorageSecurityState state = new IsolatedStorageSecurityState(); 
     state.m_Options = IsolatedStorageSecurityOptions.IncreaseQuotaForApplication;
     state.m_Quota = newQuota; 
     state.m_UsedSize = usedSize;
     return state;
 }

		public override void Write(Int64 val)
		{
			val = Utilities.SwapBytes(val);
			base.Write(val);

			if (AutoFlush) Flush();
		}

 private static Boolean HexNumberToInt64(ref NumberBuffer number, ref Int64 value)
 {
     UInt64 passedValue = 0;
     Boolean returnValue = HexNumberToUInt64(ref number, ref passedValue);
     value = (Int64)passedValue;
     return returnValue;
 }

        /// <summary>
        /// Converts a <see cref="Int64"/> to little endian notation.
        /// </summary>
        /// <param name="input">The <see cref="Int64"/> to convert.</param>
        /// <returns>The converted <see cref="Int64"/>.</returns>
        public static Int64 LittleEndian(Int64 input)
        {
            if (BitConverter.IsLittleEndian)
                return input;

            return Swap(input);
        }

        private unsafe MemoryMappedView(SafeMemoryMappedViewHandle viewHandle, Int64 pointerOffset, 
                                            Int64 size, MemoryMappedFileAccess access) {

            m_viewHandle = viewHandle;
            m_pointerOffset = pointerOffset;
            m_size = size;
            m_access = access;
        }

 internal static IsolatedStorageSecurityState CreateStateToIncreaseQuotaForGroup(String group, Int64 newQuota, Int64 usedSize) {
     IsolatedStorageSecurityState state = new IsolatedStorageSecurityState();
     state.m_Options = IsolatedStorageSecurityOptions.IncreaseQuotaForGroup;
     state.m_Group = group;
     state.m_Quota = newQuota;
     state.m_UsedSize = usedSize;
     return state;
 }

        public static byte[] Int64(Int64 i, Endianness e = Endianness.Machine)
        {
            byte[] bytes = BitConverter.GetBytes(i);

            if (NeedsFlipping(e)) Array.Reverse(bytes);

            return bytes;
        }

 public static bool UserExist(Int64 id)
 {
     String where = String.Format("id = {0}", id);
     DataRow userData = Db.Instance.dSet.users.FindByid(id);
     if (userData != null)
     {
         return true;
     }
     return false;
 }

        // Returns true if merging the number will not increase the number of ranges past MaxSequenceRanges.
        public static bool CanMerge(Int64 sequenceNumber, SequenceRangeCollection ranges)
        {
            if (ranges.Count < ReliableMessagingConstants.MaxSequenceRanges)
            {
                return true;
            }

            ranges = ranges.MergeWith(sequenceNumber);
            return ranges.Count <= ReliableMessagingConstants.MaxSequenceRanges;
        }

 public static void Write(this BinaryWriter writer, Int64 value, bool invertEndian = false)
 {
     if (invertEndian)
     {
         writer.WriteInvertedBytes(BitConverter.GetBytes(value));
     }
     else
     {
         writer.Write(value);
     }
 }

        public void OnHandshake(IPeerWireClient peerWireClient, byte[] handshake)
        {
            BDict dict = (BDict)BencodingUtils.Decode(handshake);
            if (dict.ContainsKey("metadata_size"))
            {
                BInt size = (BInt)dict["metadata_size"];
                _metadataSize = size;
                _pieceCount = (Int64)Math.Ceiling((double)_metadataSize / 16384);
            }

            RequestMetaData(peerWireClient);
        }

        public SequenceRange(Int64 lower, Int64 upper)
        {
            if (lower < 0)
            {
                throw Fx.AssertAndThrow("Argument lower cannot be negative.");
            }

            if (lower > upper)
            {
                throw Fx.AssertAndThrow("Argument upper cannot be less than argument lower.");
            }

            this.lower = lower;
            this.upper = upper;
        }

		private static void TestList()
		{
			var random = new Random(DateTime.UtcNow.Millisecond);

			var inputItems = new Int64[itemsCount];

			for (var index = 0; index < itemsCount; index++)
			{
				inputItems[index] = random.Next();
			}

			var result = CollectionLoadTestHelper.RunAllAsync(inputItems, concurrentWritersCount).Result;

			PrintResults(result);
		}

 unsafe public UniqueId(byte[] guid, int offset)
 {
     if (guid == null)
         throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("guid"));
     if (offset < 0)
         throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("offset", SR.GetString(SR.ValueMustBeNonNegative)));
     if (offset > guid.Length)
         throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("offset", SR.GetString(SR.OffsetExceedsBufferSize, guid.Length)));
     if (guidLength > guid.Length - offset)
         throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SR.GetString(SR.XmlArrayTooSmallInput, guidLength), "guid"));
     fixed (byte* pb = &guid[offset])
     {
         this.idLow = UnsafeGetInt64(pb);
         this.idHigh = UnsafeGetInt64(&pb[8]);
     }
 }

        //shouldn't ever read the byte at position endExtraField
        //assumes we are positioned at the beginning of an extra field subfield
        public static Boolean TryReadBlock(BinaryReader reader, Int64 endExtraField, out ZipGenericExtraField field)
        {
            field = new ZipGenericExtraField();

            //not enough bytes to read tag + size
            if (endExtraField - reader.BaseStream.Position < 4)
                return false;

            field._tag = reader.ReadUInt16();
            field._size = reader.ReadUInt16();

            //not enough bytes to read the data
            if (endExtraField - reader.BaseStream.Position < field._size)
                return false;

            field._data = reader.ReadBytes(field._size);
            return true;
        }

    internal sealed override void Invoke( FrameworkElement fe, FrameworkContentElement fce, Style targetStyle, FrameworkTemplate frameworkTemplate, Int64 layer )
    {
        Debug.Assert( fe != null || fce != null, "Caller of internal function failed to verify that we have a FE or FCE - we have neither." );
        Debug.Assert( targetStyle != null || frameworkTemplate != null,
            "This function expects to be called when the associated action is inside a Style/Template.  But it was not given a reference to anything." );

        INameScope nameScope = null;
        if( targetStyle != null )
        {
            nameScope = targetStyle;
        }
        else
        {
            Debug.Assert( frameworkTemplate != null );
            nameScope = frameworkTemplate;
        }

        Invoke( fe, fce, GetStoryboard( fe, fce, nameScope ) );
    }

        /// <summary>
        /// Logs remoting fragment data to verbose channel.
        /// </summary>
        /// <param name="id"></param>
        /// <param name="opcode"></param>
        /// <param name="task"></param>
        /// <param name="keyword"></param>
        /// <param name="objectId"></param>
        /// <param name="fragmentId"></param>
        /// <param name="isStartFragment"></param>
        /// <param name="isEndFragment"></param>
        /// <param name="fragmentLength"></param>
        /// <param name="fragmentData"></param>
        internal static void LogAnalyticVerbose(PSEventId id, PSOpcode opcode, PSTask task, PSKeyword keyword,
            Int64 objectId,
            Int64 fragmentId,
            int isStartFragment,
            int isEndFragment,
            UInt32 fragmentLength,
            PSETWBinaryBlob fragmentData)
        {
            if (provider.IsEnabled(PSLevel.Verbose, keyword))
            {
                string payLoadData = BitConverter.ToString(fragmentData.blob, fragmentData.offset, fragmentData.length);
                payLoadData = string.Format(CultureInfo.InvariantCulture, "0x{0}", payLoadData.Replace("-", ""));

                provider.WriteEvent(id, PSChannel.Analytic, opcode, PSLevel.Verbose, task, keyword,
                                    objectId, fragmentId, isStartFragment, isEndFragment, fragmentLength,
                                    payLoadData);
            }
        }

 /// <summary>
 /// Sets the value of a field in a record
 /// </summary>
 /// <param name="ordinal">The ordinal of the field</param>
 /// <param name="value">The new field value</param>
 public void SetInt64(int ordinal, Int64 value)
 {
     SetValue(ordinal, value);
 }