C# DICOMBinaryReader.Skip方法代码示例

 public static void SkipItemLittleEndian(DICOMBinaryReader dr, TransferSyntax syntax)
 {
     int length = LengthReader.ReadLittleEndian(VR.Null, dr.Skip(4));
     if (length != -1)
     {
         dr.Skip(length);
     }
     else
     {
         if (syntax == TransferSyntax.EXPLICIT_VR_LITTLE_ENDIAN)
         {
             while (!IsEndOfSequenceItemLittleEndian(dr))
             {
                 dr.StreamPosition -= 8;
                 DICOMElementReader.SkipElementExplicitLittleEndian(dr);
             }
         }
         else
         {
             while (!IsEndOfSequenceItemLittleEndian(dr))
             {
                 dr.StreamPosition -= 8;
                 DICOMElementReader.SkipElementImplicitLittleEndian(dr);
             }
         }
     }
 }

 public static void SkipElementImplicitLittleEndian(DICOMBinaryReader dr)
 {
     Tag tag = TagReader.ReadLittleEndian(dr);
     int length = LengthReader.ReadLittleEndian(VR.Null, dr);
     if (length != -1)
     {
         dr.Skip(length);
     }
     else
     {
         dr.Skip(SequenceReader.ReadIndefiniteLengthLittleEndian(dr, TransferSyntax.IMPLICIT_VR_LITTLE_ENDIAN));
         dr.Skip(8);
     }
 }

 public static void SkipItemBigEndian(DICOMBinaryReader dr)
 {
     int length = LengthReader.ReadBigEndian(VR.Null, dr.Skip(4));
     if (length != -1)
     {
         dr.Skip(length);
     }
     else
     {
         while (!IsEndOfSequenceItemBigEndian(dr))
         {
             dr.StreamPosition -= 8;
             DICOMElementReader.SkipElementExplicitBigEndian(dr);
         }
     }
 }

 public static int? ReadMaxLength(DICOMBinaryReader dr)
 {
     AssertItemType(dr, "Maximum Length", ItemType.MAXIMUM_LENGTH);
     dr.Skip(2); // PDU ID and Reserved Null Byte
     int length = LengthReader.ReadBigEndian(dr, 2);
     return LengthReader.ReadBigEndian(dr, 4);
 }

 private static string ReadUIDItem(DICOMBinaryReader dr, string itemName, ItemType iType)
 {
     AssertItemType(dr, itemName, iType);
     dr.Skip(2); // PDU ID and Reserved Null Byte
     int length = LengthReader.ReadBigEndian(dr, 2);
     return dr.ReadString(length).Trim();
 }

 public static AsyncOperations ReadAsyncOperations(DICOMBinaryReader dr)
 {
     AssertItemType(dr, "Async Operations", ItemType.ASYNCHRONOUS_OPERATIONS_WINDOW);
     var ao = new AsyncOperations();
     dr.Skip(2); // // PDU ID and Reserved Null Byte
     int length = LengthReader.ReadBigEndian(dr, 2);
     ao.MaxInvokeOperations = LengthReader.ReadBigEndian(dr, 2);
     ao.MaxPerformOperations = LengthReader.ReadBigEndian(dr, 2);
     return ao;
 }

 /// <summary>
 ///     Reads the data from an element encoded in big endian byte order
 /// </summary>
 /// <param name="lengthToRead">the length of the data</param>
 /// <param name="dr">the binary reader which is reading the DICOM object</param>
 /// <returns>the data from this element</returns>
 public static byte[] ReadBigEndian(int lengthToRead, DICOMBinaryReader dr)
 {
     if (lengthToRead != -1)
     {
         return dr.ReadBytes(lengthToRead);
     }
     int length = SequenceReader.ReadIndefiniteLengthBigEndian(dr);
     byte[] seqBytes = dr.ReadBytes(length);
     dr.Skip(8);
     return seqBytes;
 }

 /// <summary>
 ///     Reads the data from an element encoded in little endian byte order
 /// </summary>
 /// <param name="lengthToRead">the length of the data</param>
 /// <param name="dr">the binary reader which is reading the DICOM object</param>
 /// <returns>the data from this element</returns>
 public static byte[] ReadLittleEndian(int lengthToRead, DICOMBinaryReader dr, TransferSyntax syntax)
 {
     if (lengthToRead != -1)
     {
         return dr.ReadBytes(lengthToRead);
     }
     int length = SequenceReader.ReadIndefiniteLengthLittleEndian(dr, syntax);
     byte[] seqBytes = dr.ReadBytes(length);
     dr.Skip(8);
     return seqBytes;
 }

        public static DICOMObject ReadBigEndian(DICOMBinaryReader dr, TransferSyntax syntax)
        {
            DICOMObject d;
            int length = LengthReader.ReadLittleEndian(VR.Null, dr.Skip(4));
            if (LengthReader.IsIndefinite(length))
            {
                d = ReadIndefiniteBigEndian(dr, syntax);
            }
            else
            {
                d = DICOMObjectReader.ReadObject(dr.ReadBytes(length), syntax);
            }

            return d;
        }

        /// <summary>
        ///     Reads the length in little endian byte format from a series of bytes in a stream. The number of bytes is
        ///     automatically determined from
        ///     VR.
        /// </summary>
        /// <param name="vr">the value representation of the element</param>
        /// <param name="dr">the binary stream with a current position on the length parameter</param>
        /// <returns></returns>
        public static int ReadLittleEndian(VR vr, DICOMBinaryReader dr)
        {
            int length = 0;

            switch (VRDictionary.GetEncodingFromVR(vr))
            {
                case VREncoding.Implicit:
                    byte[] byteLength = dr.ReadBytes(4);
                    length = BitConverter.ToInt32(byteLength, 0);
                    break;
                case VREncoding.ExplicitLong:
                    byteLength = dr.Skip(2).ReadBytes(4);
                    length = BitConverter.ToInt32(byteLength, 0);
                    break;
                case VREncoding.ExplicitShort:
                    byteLength = dr.ReadBytes(2);
                    length = BitConverter.ToUInt16(byteLength, 0);
                    break;
            }
            return length;
        }

 private static PresentationContext ReadPresentationCtxContents(byte[] contents, bool requestType = false)
 {
     var pc = new PresentationContext();
     pc.TransferSyntaxes = new List<string>();
     using (var dr = new DICOMBinaryReader(contents))
     {
         pc.Id = dr.Take(1)[0];
         dr.Skip(1); //Reserved Null Byte
         pc.Reason = (PresentationContextReason) Enum.ToObject(typeof (PresentationContextReason), dr.Take(1)[0]);
         dr.Skip(1); //Reserved Null Byte
         if (requestType)
         {
             pc.AbstractSyntax = ReadAbstractSyntax(dr).Trim();
         }
         while (dr.StreamPosition < dr.StreamLength)
         {
             long initPos = dr.StreamPosition;
             pc.TransferSyntaxes.Add(ReadTransferSyntax(dr));
             if (dr.StreamPosition == initPos)
             {
                 break;
             }
         }
     }
     return pc;
 }

 public static PresentationContext ReadPresentationCtxAccept(DICOMBinaryReader dr)
 {
     AssertItemType(dr, "Presentation Context Accept", ItemType.PRESENTATION_CONTEXT_ACCEPT);
     dr.Skip(2); // PDU id Reserved Null Byte
     int length = LengthReader.ReadBigEndian(dr, 2);
     return ReadPresentationCtxContents(dr.Take(length));
 }

 public static UserInfo ReadUserInfo(DICOMBinaryReader dr)
 {
     AssertItemType(dr, "User Info", ItemType.USER_INFO);
     var ui = new UserInfo();
     dr.Skip(2); // PDU ID and Reserved Null Byte
     int length = LengthReader.ReadBigEndian(dr, 2);
     if (length > 0)
     {
         ui.MaxPDULength = (int) ReadMaxLength(dr);
         ui.ImplementationUID = ReadImplementationClassUID(dr);
         if (dr.Peek(1)[0] == (byte) ItemType.ASYNCHRONOUS_OPERATIONS_WINDOW)
         {
             ui.AsynchronousOperations = ReadAsyncOperations(dr);
         }
         ui.ImplementationVersion = ReadImplementationVersion(dr);
     }
     return ui;
 }

 public static void SkipElementExplicitBigEndian(DICOMBinaryReader dr)
 {
     Tag tag = TagReader.ReadBigEndian(dr);
     VR vr = VRReader.Read(dr);
     int length = LengthReader.ReadBigEndian(vr, dr);
     if (length != -1)
     {
         dr.Skip(length);
     }
     else
     {
         dr.Skip(SequenceReader.ReadIndefiniteLengthBigEndian(dr));
         dr.Skip(8);
     }
 }

        /// <summary>
        ///     Reads the length in big endian byte format from a series of bytes in a stream. The number of bytes is automatically
        ///     determined from
        ///     VR.
        /// </summary>
        /// <param name="vr">the value representation of the element</param>
        /// <param name="dr">the binary stream with a current position on the length parameter</param>
        /// <returns></returns>
        public static int ReadBigEndian(VR vr, DICOMBinaryReader dr)
        {
            byte[] bytes = null;

            switch (VRDictionary.GetEncodingFromVR(vr))
            {
                case VREncoding.Implicit:
                    bytes = dr.ReadBytes(4);
                    break;
                case VREncoding.ExplicitLong:
                    bytes = dr.Skip(2).ReadBytes(4);
                    break;
                case VREncoding.ExplicitShort:
                    bytes = dr.ReadBytes(2);
                    break;
            }
            return ReadBigEndian(bytes);
        }