C# DicomTag类代码示例

		public void OnBeginSequence(IByteSource source, DicomTag tag, uint length) {
			DicomSequence sq = new DicomSequence(tag);
			_sequences.Push(sq);

			DicomDataset ds = _datasets.Peek();
			ds.Add(sq);
		}

 public DicomReaderEventArgs(long position, DicomTag tag, DicomVR vr, IByteBuffer data)
 {
     Position = position;
     Tag = tag;
     VR = vr;
     Data = data;
 }

 public void OnBeginSequence(IByteSource source, DicomTag tag, uint length)
 {
     _currentSequenceTag.Push(tag);
     if (tag == DicomTag.DirectoryRecordSequence) {
         _directoryRecordSequence = _dataset.Get<DicomSequence>(tag);
     }
 }

        public void TestFile()
        {
            string filename = "OutOfRange.dcm";

            DicomFile file = new DicomFile(filename, new DicomAttributeCollection(), new DicomAttributeCollection());
            SetupMR(file.DataSet);
            SetupMetaInfo(file);

            DicomTag tag = new DicomTag(0x00030010, "Test", "TestBad", DicomVr.LOvr, false, 1, 1, false);

            file.DataSet[tag].SetStringValue("Test");

            file.Save(filename);

            file = new DicomFile(filename);

            file.DataSet.IgnoreOutOfRangeTags = true;

            file.Load();

            Assert.IsNotNull(file.DataSet.GetAttribute(tag));

            file = new DicomFile(filename);

            file.DataSet.IgnoreOutOfRangeTags = false;

            try
            {
                file.Load();
                Assert.Fail("file.Load failed");
            }
            catch (DicomException)
            {
            }
        }

        private bool IsStoredTag(DicomTag tag)
        {
            if (_metaInfo.Contains(tag))
                return true;

            //if it's meta info, just defer to the file.
            if (tag.TagValue <= 0x0002FFFF)
                return false;

            if (_xml.IsTagExcluded(tag.TagValue))
                return false;

            if (tag.VR == DicomVr.SQvr)
            {
                var items = _xml[tag].Values as DicomSequenceItem[];
                if (items != null)
                {
                    if (items.OfType<InstanceXmlDicomSequenceItem>().Any(item => item.HasExcludedTags(true)))
                        return false;
                }
            }

            bool isBinary = tag.VR == DicomVr.OBvr || tag.VR == DicomVr.OWvr || tag.VR == DicomVr.OFvr;
            //these tags are not stored in the xml.
            if (isBinary || tag.IsPrivate || tag.VR == DicomVr.UNvr)
                return false;

            return true;
        }

		public IAsyncResult BeginRead(IByteSource source, IDicomReaderObserver observer, DicomTag stop, AsyncCallback callback, object state) {
			_stop = stop;
			_observer = observer;
			_result = DicomReaderResult.Processing;
			_exception = null;
			_async = new EventAsyncResult(callback, state);
			ThreadPool.QueueUserWorkItem(ParseProc, source);
			return _async;
		}

        public void OnElement_ValidData_AddsCorrectTypeToDataset(DicomTag tag, DicomVR vr, string data, Type expected)
        {
            var dataset = new DicomDataset();
            var observer = new DicomDatasetReaderObserver(dataset);
            var buffer = new MemoryByteBuffer(Encoding.ASCII.GetBytes(data));

            observer.OnElement(null, tag, vr, buffer);
            Assert.IsType(expected, dataset.First());
        }

 public DicomNGetRequest(
     DicomUID requestedClassUid,
     DicomUID requestedInstanceUid,
     DicomTag[] attributes,
     DicomPriority priority = DicomPriority.Medium)
     : base(DicomCommandField.NGetRequest, requestedClassUid, priority)
 {
     SOPInstanceUID = requestedInstanceUid;
 }

 public void OnBeginFragmentSequence(IByteSource source, DicomTag tag, DicomVR vr)
 {
     _log.Log(
         _level,
         "{marker:x8}: {padding}{tag} {vrCode} {tagDictionaryEntryName}",
         source.Marker,
         _pad,
         tag,
         vr.Code,
         tag.DictionaryEntry.Name);
     IncreaseDepth();
 }

 public void OnBeginSequence(IByteSource source, DicomTag tag, uint length)
 {
     _log.Log(
         _level,
         "{marker:x8}: {padding}{tag} SQ {length}",
         source.Marker,
         _pad,
         tag,
         tag.DictionaryEntry.Name,
         length);
     IncreaseDepth();
 }

 public void OnElement(IByteSource source, DicomTag tag, DicomVR vr, IByteBuffer data)
 {
     _log.Log(
         _level,
         "{marker:x8}: {padding}{tag} {vrCode} {tagDictionaryEntryName} [{size}]",
         source.Marker,
         _pad,
         tag,
         vr.Code,
         tag.DictionaryEntry.Name,
         data.Size);
 }

        public void OnBeginFragmentSequence(IByteSource source, DicomTag tag, DicomVR vr)
        {
            if (vr == DicomVR.OB)
                _fragment = new DicomOtherByteFragment(tag);
            else if (vr == DicomVR.OW)
                _fragment = new DicomOtherWordFragment(tag);
            else
                throw new DicomDataException("Unexpected VR found for DICOM fragment sequence: {0}", vr.Code);

            DicomDataset ds = _datasets.Peek();
            ds.Add(_fragment);
        }

        public DicomDictionaryEntry(DicomTag tag, string name, string keyword, DicomVM vm, bool retired,
                                    params DicomVr[] vrs)
        {
            Tag = tag;

            Name = string.IsNullOrWhiteSpace(name) ? tag.ToString() : name;

            Keyword = string.IsNullOrWhiteSpace(keyword) ? Name : keyword;

            ValueMultiplicity = vm;
            ValueRepresentations = vrs;
            IsRetired = retired;
        }

        public void ConvertAttributeToUN(DicomAttributeCollection theSet, uint tag)
        {
            ByteBuffer theData =
                theSet[tag].GetByteBuffer(TransferSyntax.ImplicitVrLittleEndian,
                                          theSet.SpecificCharacterSet);

            DicomTag baseTag = DicomTagDictionary.GetDicomTag(tag);
            DicomTag theTag = new DicomTag(tag,
                baseTag.Name, baseTag.VariableName, DicomVr.UNvr, baseTag.MultiVR, baseTag.VMLow, baseTag.VMHigh, baseTag.Retired);

            DicomAttribute unAttrib = DicomVr.UNvr.CreateDicomAttribute(theTag, theData);
            theSet[tag] = unAttrib;
        }

		public void TestIgnoreOutOfRangeTags()
		{
			DicomFile file = new DicomFile();
			DicomAttributeCollection collection = file.DataSet;

			SetupMR(collection);
			collection.IgnoreOutOfRangeTags = true;

			DicomTag tag = new DicomTag(0x00030010, "Test", "TestBad", DicomVr.STvr, false, 1, 1, false);

			Assert.IsNotNull(collection.GetAttribute(tag));
			Assert.IsNotNull(collection[tag]);
	
			try
			{
				DicomAttribute attrib = collection[tag.TagValue];
				Assert.Fail("DicomAttributeCollection.GetAttribute failed");
			}
			catch (DicomException)
			{
			}

			collection.IgnoreOutOfRangeTags = false;

			try
			{
				collection.GetAttribute(tag);
				Assert.Fail("DicomAttributeCollection.GetAttribute failed");
			}
			catch (DicomException)
			{
			}

			try
			{
				DicomAttribute attrib = collection[tag];
				Assert.Fail("DicomAttributeCollection.GetAttribute failed");
			}
			catch (DicomException)
			{
			}

			try
			{
				DicomAttribute attrib = collection[tag.TagValue];
				Assert.Fail("DicomAttributeCollection.GetAttribute failed");
			}
			catch (DicomException)
			{
			}
		}