wuvist

动态修改.Net StreamReader Encoding编码

原文网址:http://www.blogwind.com/Wuvist/42999.shtml

在.Net framework中StreamReader的使用encoding必须在构造器中指定,而且中途完全不可以更改。

在一般的情况下,这不会造成什么问题。一般若是从硬盘读取文件,单一文件内的编码一般都是统一的。即便是发现读错,亦可以关闭StreamReader,重启使用新的编码读取。

偏偏偶最近遇到了需要修改编码的需求,而且,我的程序没有关闭重读的机会。因为偶使用的StreamReader的BaseStream是一个Network Stream,我不可以关闭它……但是Network Stream传过来的东西很可能包涵不同的编码……GB2312,Big5,UTF8,ISO-8859-1等等……虽然是先得到编码信息,然后再读具体内容,但是,一开始使用的Stream Reader编码一旦错了,读出来的东西便再也无法恢复……会丢字之类的……

我也不可以在获得编码信息之后,重新建立一个新的Stream Reader,因为具体内容已经被原来的Stream Reader给缓冲掉了……

唯一的解决方法,便是自己实现一个可以改变CurrentEncoding属性的Stream Reader了……

全部从头写起非常不实际,偶是先当了mono源码,从mono的Stream Reader实现代码做修改。

Stream Reader其实很简单,它内部有两个Buffer,一个是input buffer,一个是decoded buffer,前者用于缓存从base stream读过来的原始数据,后者用于缓存根据原始数据解码出来后的东西……只要看明白mono的实现中ReadBuffer这个方法,要动态修改CurrentEncoding也就不是太难了……

我需要处理的网络协议是一个行协议……偶在程序中只调用了StreamReader的Readline方法,而完全没有使用Read的两个方法,这也使得偶动态修改编码容易了许多……

偶的做法是每次调用Readline的时候,不仅移动decoded buffer的游标(pos),同时也移动input buffer一个新的游标(pos_input),做法很简单,Readline方法需要调用FindNextEOL移动游标查找换行符号……我在FindNextEOL方法添加多一行:
  int FindNextEOL ()
  {
   FindNextInputEOL();
   ....

而FindNextInputEOL这个新的函数,完全是FindNextEOL的翻版,只是前者处理input buffer,而后者处理decoded buffer……

如此一来,我便可以知道每次Readline之后,input buffer中还没有被上层读到的原始数据有哪些了……

然后,再把CurrentEncoding属性添加Set的方法:
set
   {
    encoding=value;
    decoder = encoding.GetDecoder();
    decoded_count = pos + decoder.GetChars (input_buffer, pos_input, cbEncoded , pos_input, decoded_buffer, pos);
   }

设定新编码时,程序便根据input buffer的游标(pos_input)把没有被读到的原始数据重新decode一次,并且替换掉decoded buffer中的内容。

然后,事情就搞定了……甚至不需要对Readline方法做任何修改……除了把cbEncoded这个变量放到全局里面外……

但是,偶这个修改使得Read的两个方法变得完全不可以用……一旦调用了……便会使得input buffer与decoded buffer里面两个游标不同步……下面附上完整的代码,还望有大侠可以帮忙把Read的两个方法也给搞定了…… 先谢过……

/
// System.IO.StreamReader.cs
//
// Author:
//   Dietmar Maurer (dietmar@ximian.com)
//   Miguel de Icaza (miguel@ximian.com) 
//
// (C) Ximian, Inc.  http://www.ximian.com
// Copyright (C) 2004 Novell (http://www.novell.com)
//

//
// Copyright (C) 2004 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
// 
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
// 
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//

using System;
using System.Text;
using System.Runtime.InteropServices;

namespace System.IO 
{
    [Serializable]
    
public class DynamicStreamReader : TextReader 
    
{

        
const int DefaultBufferSize = 1024;
        
const int DefaultFileBufferSize = 4096;
        
const int MinimumBufferSize = 128;

        
//
        
// The input buffer
        
//
        byte [] input_buffer;

        
//
        
// The decoded buffer from the above input buffer
        
//
        char [] decoded_buffer;

        
//
        
// Decoded bytes in decoded_buffer.
        
//
        int decoded_count;

        
//
        
// Current position in the decoded_buffer
        
//
        int pos;

        
//
        
// Current position in the input_buffer
        
//
        int pos_input;

        
//
        
// The buffer size that we are using
        
//
        int buffer_size;

        
int do_checks;
        
        Encoding encoding;
        Decoder decoder;

        Stream base_stream;
        
bool mayBlock;
        StringBuilder line_builder;

        
private class NullStreamReader : DynamicStreamReader 
        
{
            
public override int Peek ()
            
{
                
return -1;
            }


            
public override int Read ()
            
{
                
return -1;
            }


            
public override int Read ([In, Out] char[] buffer, int index, int count)
            
{
                
return 0;
            }


            
public override string ReadLine ()
            
{
                
return null;
            }


            
public override string ReadToEnd ()
            
{
                
return String.Empty;
            }


            
public override Stream BaseStream
            
{
                
get return Stream.Null; }
            }


            
public override Encoding CurrentEncoding
            
{
                
get return Encoding.Unicode; }
            }

        }


        
public new static readonly DynamicStreamReader Null =  (DynamicStreamReader)(new NullStreamReader());
        
        
internal DynamicStreamReader() {}

        
public DynamicStreamReader(Stream stream)
            : 
this (stream, Encoding.UTF8, true, DefaultBufferSize) { }

        
public DynamicStreamReader(Stream stream, bool detect_encoding_from_bytemarks)
            : 
this (stream, Encoding.UTF8, detect_encoding_from_bytemarks, DefaultBufferSize) { }

        
public DynamicStreamReader(Stream stream, Encoding encoding)
            : 
this (stream, encoding, true, DefaultBufferSize) { }

        
public DynamicStreamReader(Stream stream, Encoding encoding, bool detect_encoding_from_bytemarks)
            : 
this (stream, encoding, detect_encoding_from_bytemarks, DefaultBufferSize) { }
        
        
public DynamicStreamReader(Stream stream, Encoding encoding, bool detect_encoding_from_bytemarks, int buffer_size)
        
{
            Initialize (stream, encoding, detect_encoding_from_bytemarks, buffer_size);
        }


        
public DynamicStreamReader(string path)
            : 
this (path, Encoding.UTF8, true, DefaultFileBufferSize) { }

        
public DynamicStreamReader(string path, bool detect_encoding_from_bytemarks)
            : 
this (path, Encoding.UTF8, detect_encoding_from_bytemarks, DefaultFileBufferSize) { }

        
public DynamicStreamReader(string path, Encoding encoding)
            : 
this (path, encoding, true, DefaultFileBufferSize) { }

        
public DynamicStreamReader(string path, Encoding encoding, bool detect_encoding_from_bytemarks)
            : 
this (path, encoding, detect_encoding_from_bytemarks, DefaultFileBufferSize) { }
        
        
public DynamicStreamReader(string path, Encoding encoding, bool detect_encoding_from_bytemarks, int buffer_size)
        
{
            
if (null == path)
                
throw new ArgumentNullException("path");
            
if (String.Empty == path)
                
throw new ArgumentException("Empty path not allowed");
            
if (path.IndexOfAny (Path.InvalidPathChars) != -1)
                
throw new ArgumentException("path contains invalid characters");
            
if (null == encoding)
                
throw new ArgumentNullException ("encoding");
            
if (buffer_size <= 0)
                
throw new ArgumentOutOfRangeException ("buffer_size""The minimum size of the buffer must be positive");

            
string DirName = Path.GetDirectoryName(path);
            
if (DirName != String.Empty && !Directory.Exists(DirName))
                
throw new DirectoryNotFoundException ("Directory '" + DirName + "' not found.");
            
if (!File.Exists(path))
                
throw new FileNotFoundException("File not found.", path);

            Stream stream 
= (Stream) File.OpenRead (path);
            Initialize (stream, encoding, detect_encoding_from_bytemarks, buffer_size);
        }


        
internal void Initialize (Stream stream, Encoding encoding, bool detect_encoding_from_bytemarks, int buffer_size)
        
{
            
if (null == stream)
                
throw new ArgumentNullException ("stream");
            
if (null == encoding)
                
throw new ArgumentNullException ("encoding");
            
if (!stream.CanRead)
                
throw new ArgumentException ("Cannot read stream");
            
if (buffer_size <= 0)
                
throw new ArgumentOutOfRangeException ("buffer_size""The minimum size of the buffer must be positive");

            
if (buffer_size < MinimumBufferSize)
                buffer_size 
= MinimumBufferSize;

            base_stream 
= stream;
            input_buffer 
= new byte [buffer_size];
            
this.buffer_size = buffer_size;
            
this.encoding = encoding;
            decoder 
= encoding.GetDecoder ();

            
byte [] preamble = encoding.GetPreamble ();
            do_checks 
= detect_encoding_from_bytemarks ? 1 : 0;
            do_checks 
+= (preamble.Length == 0? 0 : 2;
            
            decoded_buffer 
= new char [encoding.GetMaxCharCount (buffer_size)];
            decoded_count 
= 0;
            pos 
= 0;
            pos_input 
=0;
        }


        
public virtual Stream BaseStream
        
{
            
get 
            
{
                
return base_stream;
            }

        }


        
public virtual Encoding CurrentEncoding
        
{
            
get 
            
{
                
if (encoding == null)
                    
throw new Exception ();
                
return encoding;
            }

            
set
            
{
                encoding
=value;
                decoder 
= encoding.GetDecoder();
                decoded_count 
= pos + decoder.GetChars (input_buffer, pos_input, cbEncoded - pos_input, decoded_buffer, pos);
                
//DiscardBufferedData();
            }

        }


        
public override void Close ()
        
{
            Dispose (
true);
        }


        
protected override void Dispose (bool disposing)
        
{
            
if (disposing && base_stream != null)
                base_stream.Close ();
            
            input_buffer 
= null;
            decoded_buffer 
= null;
            encoding 
= null;
            decoder 
= null;
            base_stream 
= null;
            
base.Dispose (disposing);
        }


        
//
        
// Provides auto-detection of the encoding, as well as skipping over
        
// byte marks at the beginning of a stream.
        
//
        int DoChecks (int count)
        
{
            
if ((do_checks & 2== 2)
            
{
                
byte [] preamble = encoding.GetPreamble ();
                
int c = preamble.Length;
                
if (count >= c)
                
{
                    
int i;
                    
                    
for (i = 0; i < c; i++)
                        
if (input_buffer [i] != preamble [i])
                            
break;

                    
if (i == c)
                        
return i;
                }

            }


            
if ((do_checks & 1== 1)
            
{
                
if (count < 2)
                    
return 0;

                
if (input_buffer [0== 0xfe && input_buffer [1== 0xff)
                
{
                    
this.encoding = Encoding.BigEndianUnicode;
                    
return 2;
                }


                
if (input_buffer [0== 0xff && input_buffer [1== 0xfe)
                
{
                    
this.encoding = Encoding.Unicode;
                    
return 2;
                }


                
if (count < 3)
                    
return 0;

                
if (input_buffer [0== 0xef && input_buffer [1== 0xbb && input_buffer [2== 0xbf)
                
{
                    
this.encoding = Encoding.UTF8;
                    
return 3;
                }

            }


            
return 0;
        }


        
public void DiscardBufferedData ()
        
{
            pos 
= decoded_count = 0;
            mayBlock 
= false;
            
// Discard internal state of the decoder too.
            decoder = encoding.GetDecoder ();
        }

        
        
int cbEncoded; 
        
int parse_start;
        
// the buffer is empty, fill it again
        private int ReadBuffer ()
        
{
            pos 
= 0;
            pos_input 
= 0;
            cbEncoded 
= 0;

            
// keep looping until the decoder gives us some chars
            decoded_count = 0;
            parse_start 
= 0;
            
do    
            
{
                cbEncoded 
= base_stream.Read (input_buffer, 0, buffer_size);
                
                
if (cbEncoded == 0)
                    
return 0;

                mayBlock 
= (cbEncoded < buffer_size);
                
if (do_checks > 0)
                
{
                    Encoding old 
= encoding;
                    parse_start 
= DoChecks (cbEncoded);
                    
if (old != encoding)
                    
{
                        decoder 
= encoding.GetDecoder ();
                    }

                    do_checks 
= 0;
                    cbEncoded 
-= parse_start;
                }

                decoded_count 
+= decoder.GetChars (input_buffer, parse_start, cbEncoded, decoded_buffer, 0);
                parse_start 
= 0;
            }
 while (decoded_count == 0);

            
return decoded_count;
        }


        
public override int Peek ()
        
{
            
if (base_stream == null)
                
throw new ObjectDisposedException ("StreamReader""Cannot read from a closed StreamReader");
            
if (pos >= decoded_count && (mayBlock || ReadBuffer () == 0))
                
return -1;

            
return decoded_buffer [pos];
        }


        
public override int Read ()
        
{
            
throw new Exception("Dynamic Reader could not read!");
        }


        
public override int Read ([In, Out] char[] dest_buffer, int index, int count)
        
{
            
throw new Exception("Dynamic Reader could not read!");
        }


        
bool foundCR_input;
        
int FindNextInputEOL()
        
{
            
char c = '\0';
            
for (; pos_input < cbEncoded; pos_input++
            
{
                c 
= (char)input_buffer [pos_input];
                
if (c == '\n'
                
{
                    pos_input
++;
                    
int res = (foundCR_input) ? (pos_input - 2) : (pos_input - 1);
                    
if (res < 0)
                        res 
= 0// if a new buffer starts with a \n and there was a \r at
                    
// the end of the previous one, we get here.
                    foundCR_input = false;
                    
return res;
                }
 
                
else if (foundCR_input) 
                
{
                    foundCR_input 
= false;
                    
return pos - 1;
                }


                foundCR_input 
= (c == '\r');
            }


            
return -1;
        }


        
bool foundCR;
        
int FindNextEOL ()
        
{
            FindNextInputEOL();
            
char c = '\0';
            
for (; pos < decoded_count; pos++
            
{
                c 
= decoded_buffer [pos];
                
if (c == '\n'
                
{
                    pos
++;
                    
int res = (foundCR) ? (pos - 2) : (pos - 1);
                    
if (res < 0)
                        res 
= 0// if a new buffer starts with a \n and there was a \r at
                    
// the end of the previous one, we get here.
                    foundCR = false;
                    
return res;
                }
 
                
else if (foundCR) 
                
{
                    foundCR 
= false;
                    
return pos - 1;
                }


                foundCR 
= (c == '\r');
            }


            
return -1;
        }


        
public override string ReadLine()
        
{
            
if (base_stream == null)
                
throw new ObjectDisposedException ("StreamReader""Cannot read from a closed StreamReader");

            
if (pos >= decoded_count && ReadBuffer () == 0)
                
return null;

            
int begin = pos;
            
int end = FindNextEOL ();
            
if (end < decoded_count && end >= begin)
                
return new string (decoded_buffer, begin, end - begin);

            
if (line_builder == null)
                line_builder 
= new StringBuilder ();
            
else
                line_builder.Length 
= 0;

            
while (true
            
{
                
if (foundCR) // don't include the trailing CR if present
                    decoded_count--;

                line_builder.Append (
new string (decoded_buffer, begin, decoded_count - begin));
                
if (ReadBuffer () == 0
                
{
                    
if (line_builder.Capacity > 32768
                    
{
                        StringBuilder sb 
= line_builder;
                        line_builder 
= null;
                        
return sb.ToString (0, sb.Length);
                    }

                    
return line_builder.ToString (0, line_builder.Length);
                }


                begin 
= pos;
                end 
= FindNextEOL ();
                
if (end < decoded_count && end >= begin) 
                
{
                    line_builder.Append (
new string (decoded_buffer, begin, end - begin));
                    
if (line_builder.Capacity > 32768
                    
{
                        StringBuilder sb 
= line_builder;
                        line_builder 
= null;
                        
return sb.ToString (0, sb.Length);
                    }

                    
return line_builder.ToString (0, line_builder.Length);
                }

            }

        }


        
public override string ReadToEnd()
        
{
            
if (base_stream == null)
                
throw new ObjectDisposedException ("StreamReader""Cannot read from a closed StreamReader");

            StringBuilder text 
= new StringBuilder ();

            
int size = decoded_buffer.Length;
            
char [] buffer = new char [size];
            
int len;
            
            
while ((len = Read (buffer, 0, size)) > 0)
                text.Append (buffer, 
0, len);

            
return text.ToString ();
        }

    }

}

posted on 2006-09-05 23:18  问天  阅读(3272)  评论(4编辑  收藏  举报

导航