public void ViewIO()
        {
            SparseMemoryStream memStream = new SparseMemoryStream();

            memStream.SetLength(1024);

            ThreadSafeStream tss = new ThreadSafeStream(memStream);

            SparseStream altView = tss.OpenView();

            // Check positions are independant
            tss.Position = 100;
            Assert.Equal(0, altView.Position);
            Assert.Equal(100, tss.Position);

            // Check I/O is synchronous
            byte[] buffer = new byte[200];
            tss.WriteByte(99);
            altView.Read(buffer, 0, 200);
            Assert.Equal(99, buffer[100]);

            // Check positions are updated correctly
            Assert.Equal(200, altView.Position);
            Assert.Equal(101, tss.Position);
        }
示例#2
0
        // Methods
        #region FileSend
        void FileSend()
        {
            //This is our progress percent, between 0 and 1
            double progressPercentage = 0;

            //Initialise stream with 1MB
            byte[]           buffer         = new byte[1024 * 1024];
            ThreadSafeStream dataToSend     = new ThreadSafeStream(new System.IO.MemoryStream(buffer));
            long             totalBytesSent = 0;

            //We will send in chunks of 50KB
            int sendInChunksOfNBytes = 50 * 1024;

            //Get the connection to the target
            Connection connection = TCPConnection.GetConnection(new ConnectionInfo(this.serverIp, this.serverPort));

            do
            {
                //Determine the total number of bytes to send
                //We need to watch out for the end of the buffer when we send less than sendInChunksOfNBytes
                long bytesToSend = (buffer.Length - totalBytesSent > sendInChunksOfNBytes ? sendInChunksOfNBytes : buffer.Length - totalBytesSent);
                StreamSendWrapper streamWrapper = new StreamSendWrapper(dataToSend, totalBytesSent, bytesToSend);
                connection.SendObject("PartitionedSend", streamWrapper);
                totalBytesSent    += bytesToSend;
                progressPercentage = ((double)totalBytesSent / buffer.Length);
            }while (totalBytesSent < buffer.Length);
        }
 /// <summary>
 /// 傳送檔案
 /// </summary>
 /// <param name="Token">權杖</param>
 /// <param name="IPaddress">IP位址</param>
 /// <param name="Port">Port號</param>
 /// <param name="FilePath">檔案路徑</param>
 public void FileFunction(string Token, string IPaddress, int Port, string FilePath)
 {
     try
     {
         FileStream   fileStream   = new FileStream(FilePath, FileMode.Open, FileAccess.Read);
         StreamReader streamReader = new StreamReader(fileStream);
         DataTable    dataTable    = new DataTable();
         bool         IsFirst      = true;
         string       strline      = null;
         while ((strline = streamReader.ReadLine()) != null)
         {
             if (IsFirst)
             {
                 try
                 {
                     ThreadSafeStream  threadSafeStream = new ThreadSafeStream(fileStream);
                     StreamSendWrapper sendWrapper      = new StreamSendWrapper(threadSafeStream, 0, fileStream.Length);
                     NetworkComms.SendObject(Token, IPaddress, Port, sendWrapper);
                     fileStream.Close();
                 }
                 catch (ArgumentException ex) { Log.Error("網路通訊異常請檢查", ex); ErrorStr = "網路通訊異常請檢查"; }
                 catch (ConnectionSetupException ex) { Log.Error("網路通訊異常請檢查", ex); ErrorStr = "網路通訊異常請檢查"; }
                 catch (ConnectionSendTimeoutException ex) { Log.Error("接收端程式異常", ex); ErrorStr = "接收端程式異常"; }
                 catch (Exception ex) { Log.Error(ex, "傳送檔案失敗"); }
             }
             break;
         }
     }
     catch (FileNotFoundException ex) { Log.Error("搜尋不到或未有檔案產生", ex); ErrorStr = "搜尋不到或未有檔案產生"; }
     catch (ObjectDisposedException ex) { Log.Error("檔案刪除後未有檔案產生", ex); ErrorStr = "檔案刪除後未有檔案產生"; }
     catch (DirectoryNotFoundException ex) { Log.Error("找不到檔案路徑", ex); ErrorStr = "找不到檔案路徑"; }
 }
        public void CanRead()
        {
            SparseMemoryStream memStream = new SparseMemoryStream(new SparseMemoryBuffer(1), FileAccess.ReadWrite);
            ThreadSafeStream   tss       = new ThreadSafeStream(memStream);

            Assert.Equal(true, tss.CanRead);

            memStream = new SparseMemoryStream(new SparseMemoryBuffer(1), FileAccess.Write);
            tss       = new ThreadSafeStream(memStream);
            Assert.Equal(false, tss.CanRead);
        }
示例#5
0
        void OpenFileSend()
        {
            long totalBytesSent = 0;

            //Get the connection to the target
            Connection connection = TCPConnection.GetConnection(new ConnectionInfo(this.serverIp, this.serverPort));

            OpenFileDialog fd = new OpenFileDialog();

            if (fd.ShowDialog() == DialogResult.OK)
            {
                string filePath = fd.FileName;
                var    fileName = System.IO.Path.GetFileName(filePath);

                using (var file = new FileStream(filePath, FileMode.Open))
                {
                    using (var safeStream = new ThreadSafeStream(file))
                    {
                        var sendChunkSizeBytes = (long)(file.Length / 20.0) + 1;

                        //Limit send chunk size to 500MB
                        const long maxChunkSizeBytes = 500L * 1024L * 1024L;
                        if (sendChunkSizeBytes > maxChunkSizeBytes)
                        {
                            sendChunkSizeBytes = maxChunkSizeBytes;
                        }

                        totalBytesSent = 0;
                        do
                        {
                            //Check the number of bytes to send as the last one may be smaller
                            var bytesToSend = (totalBytesSent + sendChunkSizeBytes < file.Length ? sendChunkSizeBytes : file.Length - totalBytesSent);

                            //Wrap the threadSafeStream in a StreamSendWrapper so that we can get NetworkComms.Net
                            //to only send part of the stream.
                            using (var streamWrapper = new StreamSendWrapper(safeStream, totalBytesSent, bytesToSend))
                            {
                                //We want to record the packetSequenceNumber
                                long packetSequenceNumber;

                                connection.SendObject("PartitionedSend", streamWrapper);
                                //Send the select data
                                //connection.SendObject("PartialFileData", streamWrapper, NetworkComms.DefaultSendReceiveOptions, out packetSequenceNumber);
                                //Send the associated SendInfo for this send so that the remote can correctly rebuild the data
                                //connection.SendObject("PartialFileDataInfo", new SendInfo(fileName, file.Length, totalBytesSent, packetSequenceNumber));
                                totalBytesSent += bytesToSend;
                            }
                        } while (totalBytesSent < file.Length);
                    }
                }
            }
        }
示例#6
0
            /// <summary>
            /// Create a new stream wrapper
            /// </summary>
            /// <param name="stream">The underlying stream</param>
            /// <param name="start">The start position from where to read data</param>
            /// <param name="length">The length to read</param>
            public StreamSendWrapper(ThreadSafeStream stream, long start, long length)
            {
                if (start < 0)
                {
                    throw new Exception("Provided start value cannot be less than 0.");
                }

                if (length < 0)
                {
                    throw new Exception("Provided length value cannot be less than 0.");
                }

                this.ThreadSafeStream = stream;
                this.Start            = start;
                this.Length           = length;
            }
        public void Seek()
        {
            SparseMemoryStream memStream = new SparseMemoryStream(new SparseMemoryBuffer(1), FileAccess.ReadWrite);

            memStream.SetLength(1024);

            ThreadSafeStream tss = new ThreadSafeStream(memStream);

            tss.Seek(10, SeekOrigin.Begin);
            Assert.Equal(10, tss.Position);

            tss.Seek(10, SeekOrigin.Current);
            Assert.Equal(20, tss.Position);

            tss.Seek(-10, SeekOrigin.End);
            Assert.Equal(1014, tss.Position);
        }
        public void DisposeView()
        {
            SparseMemoryStream memStream = new SparseMemoryStream(new SparseMemoryBuffer(1), FileAccess.ReadWrite);

            memStream.SetLength(1024);

            ThreadSafeStream tss = new ThreadSafeStream(memStream);

            SparseStream altView = tss.OpenView();

            altView.Dispose();

            tss.ReadByte();

            SparseStream altView2 = tss.OpenView();

            altView2.ReadByte();
        }
        public void ChangeLengthFails()
        {
            SparseMemoryStream memStream = new SparseMemoryStream();

            memStream.SetLength(2);

            ThreadSafeStream tss = new ThreadSafeStream(memStream);

            Assert.Equal(2, tss.Length);

            try
            {
                tss.SetLength(10);
                Assert.True(false, "SetLength should fail");
            }
            catch (NotSupportedException)
            {
            }
        }
        public void Dispose_StopsView()
        {
            SparseMemoryStream memStream = new SparseMemoryStream(new SparseMemoryBuffer(1), FileAccess.ReadWrite);

            memStream.SetLength(1024);

            ThreadSafeStream tss = new ThreadSafeStream(memStream);

            SparseStream altView = tss.OpenView();

            tss.Dispose();

            try
            {
                altView.ReadByte();
                Assert.True(false, "Disposed stream didn't stop view");
            }
            catch (ObjectDisposedException)
            {
            }
        }
示例#11
0
            /// <summary>
            /// Return the MD5 for the specific part of the stream only.
            /// </summary>
            /// <returns></returns>
            public string MD5CheckSum()
            {
                using (MemoryStream ms = new MemoryStream())
                {
                    ThreadSafeStream.CopyTo(ms, Start, Length, 8000);

#if NETFX_CORE
                    var alg        = Windows.Security.Cryptography.Core.HashAlgorithmProvider.OpenAlgorithm(Windows.Security.Cryptography.Core.HashAlgorithmNames.Md5);
                    var buffer     = (new Windows.Storage.Streams.DataReader(ms.AsInputStream())).ReadBuffer((uint)ms.Length);
                    var hashedData = alg.HashData(buffer);
                    return(Windows.Security.Cryptography.CryptographicBuffer.EncodeToHexString(hashedData).Replace("-", ""));
#else
#if WINDOWS_PHONE
                    using (var md5 = new Tools.MD5Managed())
                    {
#else
                    using (var md5 = System.Security.Cryptography.MD5.Create())
                    {
#endif
                        return(BitConverter.ToString(md5.ComputeHash(ms)).Replace("-", ""));
                    }
#endif
                }
            }
        public void Extents()
        {
            SparseMemoryStream memStream = new SparseMemoryStream(new SparseMemoryBuffer(1), FileAccess.ReadWrite);

            memStream.SetLength(1024);

            ThreadSafeStream tss = new ThreadSafeStream(memStream);

            SparseStream altView = tss.OpenView();

            tss.Position = 100;
            tss.WriteByte(99);

            List <StreamExtent> extents = new List <StreamExtent>(altView.Extents);

            Assert.Equal(1, extents.Count);
            Assert.Equal(100, extents[0].Start);
            Assert.Equal(1, extents[0].Length);

            extents = new List <StreamExtent>(altView.GetExtentsInRange(10, 300));
            Assert.Equal(1, extents.Count);
            Assert.Equal(100, extents[0].Start);
            Assert.Equal(1, extents[0].Length);
        }
示例#13
0
 /// <summary>
 /// Dispose the internal ThreadSafeStream
 /// </summary>
 public void Dispose()
 {
     ThreadSafeStream.Dispose();
 }
 /// <summary>
 /// Create a new stream wrapper and set Start and Length to encompass the entire Stream
 /// </summary>
 /// <param name="stream">The underlying stream</param>
 public StreamSendWrapper(ThreadSafeStream stream)
 {
     this.ThreadSafeStream = stream;
     this.Start = 0;
     this.Length = stream.Length;
 }
 public void OpenView()
 {
     ThreadSafeStream tss  = new ThreadSafeStream(SparseStream.FromStream(Stream.Null, Ownership.None));
     SparseStream     view = tss.OpenView();
 }
            /// <summary>
            /// Create a new stream wrapper
            /// </summary>
            /// <param name="stream">The underlying stream</param>
            /// <param name="start">The start position from where to read data</param>
            /// <param name="length">The length to read</param>
            public StreamSendWrapper(ThreadSafeStream stream, long start, long length)
            {
                if (start < 0)
                    throw new Exception("Provided start value cannot be less than 0.");

                if (length < 0)
                    throw new Exception("Provided length value cannot be less than 0.");

                this.ThreadSafeStream = stream;
                this.Start = start;
                this.Length = length;
            }
示例#17
0
 /// <summary>
 /// Create a new stream wrapper and set Start and Length to encompass the entire Stream
 /// </summary>
 /// <param name="stream">The underlying stream</param>
 public StreamSendWrapper(ThreadSafeStream stream)
 {
     this.ThreadSafeStream = stream;
     this.Start            = 0;
     this.Length           = stream.Length;
 }