C# Decoder.GetChars方法代码示例

        // GetStringFromByteArray metodu byte dizisindeki belli uzunluktaki
        // bir parçayı alarak, string olarak döndürür.
        //
        // bytes:  Byte dizisi.
        // iStart: Byte dizisindeki başlangıç konumu.
        // iLen:   Çevrilecek  byte parçasının uzunluğu.
        // dec:    Çevirmede kullanılacak Decoder.
        public static string GetStringFromByteArray(Byte[] bytes, int iStart,
            int iLen, Decoder dec)
        {
            // Parametrelerin hata kontrolünü yap.
            if ((iStart + iLen <= bytes.Length) && (iStart >= 0) && (iLen > 0))
            {
                // Karakter dizisi nesnesi oluştur.
                Char[] chars;
                // StringBuilder nesnesi oluştur.
                StringBuilder sb = new StringBuilder();

                // GetCharCount metoduyla, byte dizisindeki kodlaması çözülecek
                // olan byte'lar için gerekli karakter sayısını hesapla.
                int iCharCount = dec.GetCharCount(bytes, iStart, iLen);
                // Karakter dizisini boyutlandır.
                chars = new Char[iCharCount];
                // GetChars metoduyla, belirtilen sayı kadar, byte dizisinden
                // alınan elemanların karakter dizisine çevrilmesi:
                dec.GetChars(bytes, iStart, iLen, chars, 0);

                // must skip null-termination of C++ string
                // Karakter dizisinin sonundaki null kontrolü için:
                for (int i = 0; i < iCharCount; ++i)
                {
                    // Konrol karakteri var mı?
                    if (Char.GetUnicodeCategory(chars[i]) != UnicodeCategory.Control)
                    {
                        // Karakter dizini doldur.
                        sb.Append(chars[i].ToString());
                    }
                    else
                    {
                        break;      // Konrol karakteri yakalandı.
                    }//if
                }//for

                return sb.ToString();
            }
            else
            {
                // Parametrelerde hata bulundu. Boş bir string çevir.
                return String.Empty;
            }
        }

 public static string ReadMinimum(this Stream stream, Decoder decoder)
 {
     var buffer = new byte[16];
     for (int i = 0; i < buffer.Length; ++i)
     {
         var read = stream.Read(buffer, i, 1);
         if (read == 0)
         {
             if (i != 0) throw new Exception("invalid encoded text?");
             return null;
         }
         var charCount = decoder.GetCharCount(buffer, 0, i + 1);
         if (charCount != 0)
         {
             var chars = new char[charCount];
             decoder.GetChars(buffer, 0, i + 1, chars, 0);
             return new string(chars);
         }
     }
     throw new Exception("impossible?");
 }

 private int IntReadChars(char[] buffer, int index, int count, Encoding encode, Decoder decoder)
 {
     int cpS = 1;
     if (encode is UnicodeEncoding)
     {
         cpS = 2;
     }
     else if (encode is UTF32Encoding)
     {
         cpS = 4;
     }
     int rem = count;
     while (rem > 0)
     {
         int read = Math.Min(rem*cpS, _bufferLength);
         read = _stream.Read(_buffer, 0, read);
         if (read == 0)
         {
             return count - rem;
         }
         read = decoder.GetChars(_buffer, 0, read, buffer, index);
         rem -= read;
         index += read;
     }
     return count;
 }

	// try to convert the all current test's bytes with Getchars()
	// in only one step
	private void DecoderFallbackExceptions_GetChars (
		char [] chars,
		int testno,
		Decoder dec,
		DecoderFallbackExceptionTest t)
	{
		try {
			dec.GetChars (t.bytes, 0, t.bytes.Length, chars, 0, true);
				Assert.IsTrue (
					t.eindex.Length == 0,
					String.Format (
						"test#{0}-1: UNEXPECTED SUCCESS",
						testno));
		} catch(DecoderFallbackException ex) {
			Assert.IsTrue (
				t.eindex.Length > 0,
				String.Format (
					"test#{0}-1: UNEXPECTED FAIL",
					testno));
			Assert.IsTrue (
				ex.Index == t.eindex[0],
				String.Format (
					"test#{0}-1: Expected exception at {1} not {2}.",
					testno,
					t.eindex[0],
					ex.Index));
			Assert.IsTrue (
				ex.BytesUnknown.Length == t.elen[0],
				String.Format (
					"test#{0}-1: Expected BytesUnknown.Length of {1} not {2}.",
					testno,
					t.elen[0],
					ex.BytesUnknown.Length));
			for (int i = 0; i < ex.BytesUnknown.Length; i++)
				Assert.IsTrue (
					ex.BytesUnknown[i] == t.bytes[ex.Index + i],
					String.Format (
						"test#{0}-1: expected byte {1:X} not {2:X} at {3}.",
						testno,
						t.bytes[ex.Index + i],
						ex.BytesUnknown[i],
						ex.Index + i));
			dec.Reset ();
		}
	}

        private void FirstRead(byte[] streamData, int readBytes, char[] characters)
        {
            Encoding encoding = selector.GetEncoding(streamData);
            decoder = encoding.GetDecoder();
            int theOffset = selector.ByteCount(encoding);

            int decoded = decoder.GetChars(streamData, theOffset, readBytes - theOffset , characters, 0);
            myCallbackDelegate(characters, decoded);
            currentRead = ReadFurther;
        }

		private int GetCharsFromStream(Stream inputStream, int count, Decoder decoder, char[] chars)
		{
			// Now, read just the field value.
			PGUtil.CheckedStreamRead(inputStream, _inputBuffer, 0, count);
			int charCount = decoder.GetCharCount(_inputBuffer, 0, count);
			decoder.GetChars(_inputBuffer, 0, count, chars, 0);
			return charCount;
		}