新建版本库

qwj

2022-08-22 63f6c5de8832eaabf066fe9f9d492187f04011b7

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
 
namespace CY_DocumentFileWCFService
{
    /// <summary>
    /// 自定义读取流（只读）
    /// </summary>
    internal class CusStreamReader : Stream
    {
        long _endPosition;//结束位置
        Stream innerStream;
        /// <summary>
        /// 参数为当前流的断点
        /// </summary>
        public event Action<long> Reading;
 
        /// <summary>
        /// 直接使用原始流。
        /// </summary>
        /// <param name="stream">原始流</param>
        public CusStreamReader(Stream stream)
        {
            this.innerStream = stream;
            _endPosition = stream.Length;
        }
        /// <summary>
        /// 使用流当前位置，指定长度初始化自定义流
        /// </summary>
        /// <param name="stream">原始流</param>
        /// <param name="count">使用长度</param>
        public CusStreamReader(Stream stream, long count)
        {
            this.innerStream = stream;
            _endPosition = stream.Position + count;
            if (_endPosition > stream.Length)
                _endPosition = stream.Length;
        }
        /// <summary>
        /// 指定初始位置、长度初始化自定义流
        /// </summary>
        /// <param name="stream">原始流</param>
        /// <param name="offset">初始位置</param>
        /// <param name="count">使用长度</param>
        public CusStreamReader(Stream stream, long offset, long count)
        {
            stream.Position = offset > stream.Length ? stream.Length : offset;
            this.innerStream = stream;
            _endPosition = offset + count;
            if (_endPosition > stream.Length)
                _endPosition = stream.Length;
        }
        /// <summary>
        /// 从自定义流读取指定长度到array，但是不超过初始化时设定的长度。
        /// </summary>
        /// <returns>读取的字节数</returns>
        public override int Read(byte[] array, int offset, int count)
        {
            int readcount = 0;
            if (Position + count > this._endPosition)
                readcount = innerStream.Read(array, offset, (int)(this._endPosition - Position));
            else
                readcount = innerStream.Read(array, offset, count);
            if (Reading != null)
                Reading(Position);
            return readcount;
        }
        /// <summary>
        /// 从自定义流读取一个字节，但是不超过初始化时设定的长度。
        /// </summary>
        /// <returns>读取的字节，未找到则返回-1</returns>
        public override int ReadByte()
        {
            if (Position >= this._endPosition)
                return -1;
            else
                return base.ReadByte();
        }
 
        public override bool CanRead
        {
            get { return innerStream.CanRead; }
        }
 
        public override bool CanSeek
        {
            get { return false; }
        }
 
        public override bool CanWrite
        {
            get { return false; }
        }
 
        public override void Flush()
        {
            throw new NotImplementedException();
        }
 
        /// <summary>
        /// 自定义流剩余长度。
        /// </summary>
        public override long Length
        {
            get { return _endPosition - innerStream.Position; }
        }
 
        /// <summary>
        /// 自定义流位置，返回原始流的位置
        /// </summary>
        public override long Position
        {
            get
            {
                return innerStream.Position;
            }
            set
            {
                throw new NotImplementedException();
            }
        }
 
        public override long Seek(long offset, SeekOrigin origin)
        {
            throw new NotImplementedException();
        }
 
        public override void SetLength(long value)
        {
            throw new NotImplementedException();
        }
 
        public override void Write(byte[] buffer, int offset, int count)
        {
            throw new NotImplementedException();
        }
    }
}