示例#1
0
 public override object InternalExecute(Program program, object[] arguments)
 {
     using (FileStream file = File.Open((string)arguments[0], FileMode.Append, FileAccess.Write, FileShare.Read))
     {
         if (Operator.Operands[1].DataType.Is(program.DataTypes.SystemString))
         {
             using (StreamWriter writer = new StreamWriter(file))
             {
                 writer.Write((string)arguments[1]);
             }
         }
         else
         {
             if (arguments[1] is StreamID)
             {
                 using (Stream sourceStream = program.StreamManager.Open((StreamID)arguments[1], LockMode.Exclusive))
                 {
                     StreamUtility.CopyStream(sourceStream, file);
                 }
             }
             else
             {
                 byte[] tempValue = (byte[])arguments[1];
                 file.Write(tempValue, 0, tempValue.Length);
             }
         }
     }
     return(null);
 }
示例#2
0
        /// <summary>
        /// Find the end of the header section in a byte array.<br/>
        /// The headers have ended when a blank line is found
        /// </summary>
        /// <param name="messageContent">The full message stored as a byte array</param>
        /// <returns>The position of the line just after the header end blank line</returns>
        /// <exception cref="ArgumentNullException">If <paramref name="messageContent"/> is <see langword="null"/></exception>
        private static int FindHeaderEndPosition(byte[] messageContent)
        {
            if (messageContent == null)
            {
                throw new ArgumentNullException("messageContent");
            }

            // Convert the byte array into a stream
            using (Stream stream = new MemoryStream(messageContent))
            {
                while (true)
                {
                    // Read a line from the stream. We know headers are in US-ASCII
                    // therefore it is not problem to read them as such
                    string line = StreamUtility.ReadLineAsAscii(stream);

                    // The end of headers is signaled when a blank line is found
                    // or if the line is null - in which case the email is actually an email with
                    // only headers but no body
                    if (string.IsNullOrEmpty(line))
                    {
                        return((int)stream.Position);
                    }
                }
            }
        }
示例#3
0
        /// <summary>
        /// Get the sizes in bytes of all the messages.<br/>
        /// Messages marked as deleted are not listed.
        /// </summary>
        /// <returns>Size of each message excluding deleted ones</returns>
        /// <exception cref="PopServerException">If the server did not accept the LIST command</exception>
        public List <int> GetMessageSizes()
        {
            AssertDisposed();

            if (State != ConnectionState.Transaction)
            {
                throw new InvalidUseException("Cannot get message sizes, when the user has not been authenticated yet");
            }

            // RFC Example:
            // C: LIST
            // S: +OK 2 messages (320 octets)
            // S: 1 120
            // S: 2 200
            // S: .       // End of multi-line

            SendCommand("LIST");

            List <int> sizes = new List <int>();

            string response;

            // Read until end of multi-line
            while (!".".Equals(response = StreamUtility.ReadLineAsAscii(Stream)))
            {
                sizes.Add(int.Parse(response.Split(' ')[1], CultureInfo.InvariantCulture));
            }

            return(sizes);
        }
示例#4
0
 private void ImageRead(PipeRequest request, Pipe pipe)
 {
     if (Active)
     {
         _imageRequest = null;
         try
         {
             if (request.Result.IsNative)
             {
                 byte[] resultBytes = request.Result.AsByteArray;
                 SetImage(System.Drawing.Image.FromStream(new MemoryStream(resultBytes, 0, resultBytes.Length, false, true)));
             }
             else
             {
                 using (Stream stream = request.Result.OpenStream())
                 {
                     MemoryStream copyStream = new MemoryStream();
                     StreamUtility.CopyStream(stream, copyStream);
                     SetImage(System.Drawing.Image.FromStream(copyStream));
                 }
             }
         }
         catch
         {
             SetImage(ImageUtility.GetErrorImage());
         }
     }
 }
示例#5
0
        /// <summary>
        /// Creates a stream with the relative path to the assembly
        /// </summary>
        public static Stream CreateRefreshFileStream(string root, string assemblyPath)
        {
            string projectPath          = PathUtility.EnsureTrailingSlash(root);
            string relativeAssemblyPath = PathUtility.GetRelativePath(projectPath, assemblyPath);

            return(StreamUtility.StreamFromString(relativeAssemblyPath));
        }
示例#6
0
        public void Write(EndianBinaryWriter writer)
        {
            long start = writer.BaseStream.Position;

            writer.WriteSignature("VTX1".ToCharArray());
            writer.Write(0);             // Placeholder for section size
            writer.Write(0x40);          // Offset to attribute data

            for (int i = 0; i < 13; i++) // Placeholders for attribute data offsets
            {
                writer.Write(0);
            }

            WriteAttributeHeaders(writer);

            StreamUtility.PadStreamWithString(writer, 32);

            WriteAttributeData(writer, (int)start);

            long end    = writer.BaseStream.Position;
            long length = (end - start);

            writer.Seek((int)start + 4, System.IO.SeekOrigin.Begin);
            writer.Write((int)length);
            writer.Seek((int)end, System.IO.SeekOrigin.Begin);
        }
示例#7
0
 protected void LoadImage()
 {
     if (!ImageSource.Loading)
     {
         try
         {
             ImageSource.LoadImage();
             if (ImageSource.Stream != null)
             {
                 using (DAE.Runtime.Data.Scalar newValue = new DAE.Runtime.Data.Scalar(ImageControl.Source.DataSet.Process.ValueManager, ImageControl.Source.DataSet.Process.DataTypes.SystemGraphic))
                 {
                     using (Stream stream = newValue.OpenStream())
                     {
                         using (ImageSource.Stream)
                         {
                             ImageSource.Stream.Position = 0;
                             StreamUtility.CopyStream(ImageSource.Stream, stream);
                             ImageControl.DataField.Value = newValue;
                             ImageControl.LoadImage();
                         }
                     }
                 }
             }
         }
         finally
         {
             if (ImageSource.GetType() == typeof(ImageCaptureForm))
             {
                 ImageSource = null;
             }
         }
     }
 }
示例#8
0
 protected void ImageRead(PipeRequest request, Pipe pipe)
 {
     _imageRequest = null;
     try
     {
         if (request.Result.IsNative)
         {
             byte[] resultBytes = request.Result.AsByteArray;
             _image = System.Drawing.Image.FromStream(new MemoryStream(resultBytes, 0, resultBytes.Length, false, true));
         }
         else
         {
             using (Stream stream = request.Result.OpenStream())
             {
                 MemoryStream copyStream = new MemoryStream();
                 StreamUtility.CopyStream(stream, copyStream);
                 _image = System.Drawing.Image.FromStream(copyStream);
             }
         }
     }
     catch
     {
         _image = ImageUtility.GetErrorImage();
     }
     FCallBack(this, new EventArgs());
 }
示例#9
0
 public void SetImageAccepted(IFormInterface AForm)
 {
     FImageSource = (IImageSource)AForm;
     if (FImageSource.Stream == null)
     {
         DataField.ClearValue();
     }
     else
     {
         using (DAE.Runtime.Data.Scalar LNewValue = new DAE.Runtime.Data.Scalar(Source.DataView.Process.ValueManager, Source.DataView.Process.DataTypes.SystemGraphic))
         {
             Stream LStream = LNewValue.OpenStream();
             try
             {
                 FImageSource.Stream.Position = 0;
                 StreamUtility.CopyStream(FImageSource.Stream, LStream);
             }
             finally
             {
                 LStream.Close();
             }
             DataField.Value = LNewValue;
         }
     }
 }
示例#10
0
        public async Task SplitIntoMailboxes()
        {
            var body = "My body\nNext Line";

            _queue.References.Add(
                new MockMailReference(
                    "int-mail",
                    "*****@*****.**",
                    new[] { "*****@*****.**", "*****@*****.**" }.ToImmutableList(),
                    true,
                    body,
                    _queue));

            await _dispatcher.ProcessAllMailReferencesAsync(CancellationToken.None);

            Assert.Empty(_queue.References);
            Assert.Empty(_transfer.References);
            Assert.Equal(2, _mailbox.SavedReferences.Count());
            var expected = new HashSet <string> {
                "*****@*****.**", "*****@*****.**"
            };

            foreach (MockMailboxItemReference r in _mailbox.SavedReferences)
            {
                Assert.Contains(r.Mailbox, expected);
                expected.Remove(r.Mailbox);
                Assert.Equal(body, await StreamUtility.ReadAllFromStreamAsync(r.BackupBodyStream));
                r.Dispose();
            }
        }
示例#11
0
        public async Task InternalSenderCanSendAnywhere()
        {
            var body = "My body\nNext Line";

            _queue.References.Add(
                new MockMailReference(
                    "ext-mail",
                    "*****@*****.**",
                    new[] { "*****@*****.**" }.ToImmutableList(),
                    true,
                    body,
                    _queue));

            await _dispatcher.ProcessAllMailReferencesAsync(CancellationToken.None);

            Assert.Empty(_queue.References);
            Assert.Equal(1, _queue.DeletedReferences.Count);
            Assert.Equal(1, _transfer.References.Count(r => r.IsSaved));
            string newBody;

            using (MockMailReference reference = _transfer.References.FirstOrDefault(r => r.IsSaved))
            {
                Assert.NotNull(reference);
                Assert.Equal("*****@*****.**", reference.Sender);
                SequenceAssert.SameSet(new[] { "*****@*****.**" }, reference.Recipients);
                newBody = await StreamUtility.ReadAllFromStreamAsync(reference.BackupBodyStream);
            }

            Assert.Equal(body, newBody);
            Assert.Empty(_mailbox.References);
        }
示例#12
0
        internal void InternalSaveToFile()
        {
            if (String.IsNullOrEmpty(_fileName))
            {
                _fileName = PromptForSaveName();
            }
            // The file must be writable to overwrite
            if (File.Exists(_fileName))
            {
                FileUtility.EnsureWriteable(_fileName);
            }

            // Write/rewrite the file
            using (FileStream fileStream = new FileStream(_fileName, FileMode.Create, FileAccess.Write))
                if (((Schema.ScalarType)DataField.DataType).NativeType == typeof(byte[]))
                {
                    using (Stream stream = DataField.Value.OpenStream())
                        StreamUtility.CopyStream(stream, fileStream);
                }
                else
                {
                    using (StreamWriter streamWriter = new StreamWriter(fileStream))
                        streamWriter.Write(DataField.Value.AsString);
                }
        }
示例#13
0
        /// <summary>
        /// Initializes a new instance of the <see cref="ErrorHtmlResponse"/> class.
        /// </summary>
        /// <param name="statusCode">The status code.</param>
        public ErrorHtmlResponse(HttpStatusCode statusCode)
        {
            this.StatusCode  = statusCode;
            this.ContentType = WebResources.ContentTypeHtmlUtf8;

            this.Contents = stream =>
            {
                string page;

                switch (this.StatusCode)
                {
                case HttpStatusCode.NotFound:
                    page = WebResources.PageNotFound;
                    break;

                case HttpStatusCode.InternalServerError:
                    page = WebResources.PageInternalServerError;
                    break;

                default:
                    page = string.Empty;
                    break;
                }

                StreamUtility.WriteUtf8StringToStream(page, stream);
            };
        }
示例#14
0
 protected void ImageRead(PipeRequest request, Pipe pipe)
 {
     if (Active)
     {
         try
         {
             _imageRequest = null;
             try
             {
                 if (request.Result.IsNative)
                 {
                     byte[] resultBytes = request.Result.AsByteArray;
                     _internalImage = System.Drawing.Image.FromStream(new MemoryStream(resultBytes, 0, resultBytes.Length, false, true));
                 }
                 else
                 {
                     using (Stream stream = request.Result.OpenStream())
                     {
                         MemoryStream copyStream = new MemoryStream();
                         StreamUtility.CopyStream(stream, copyStream);
                         _internalImage = System.Drawing.Image.FromStream(copyStream);
                     }
                 }
             }
             catch
             {
                 _internalImage = ImageUtility.GetErrorImage();
             }
         }
         finally
         {
             UpdateColumn();
         }
     }
 }
示例#15
0
        public StreamID Reference(StreamID streamID)
        {
            LocalStreamHeader targetHeader;

            if (_headers.TryGetValue(streamID, out targetHeader) && (targetHeader.Stream != null) && targetHeader.Stream.Modified)
            {
                StreamID localStreamID = Allocate();
                Stream   stream        = Open(localStreamID, LockMode.Exclusive);
                try
                {
                    Stream targetStream = new CoverStream(targetHeader.Stream);
                    try
                    {
                        StreamUtility.CopyStream(targetStream, stream);
                        return(localStreamID);
                    }
                    finally
                    {
                        targetStream.Close();
                    }
                }
                finally
                {
                    stream.Close();
                    Close(localStreamID);
                }
            }
            else
            {
                StreamID          localStreamID = _sourceStreamManager.Reference(streamID);
                LocalStreamHeader header        = new LocalStreamHeader(localStreamID);
                _headers.Add(header);
                return(localStreamID);
            }
        }
示例#16
0
        public void ProcessRequest(HttpContext AContext)
        {
            AContext.Response.ContentType = FrontendUtility.CXmlContentType;

            string LUri = HttpUtility.UrlDecode(AContext.Request.QueryString[DilxUtility.UriParameter]);

            if (LUri == null)
            {
                throw new ServerException(ServerException.Codes.MissingParameter, DilxUtility.UriParameter);
            }
            LUri = AContext.Request.MapPath(new Uri(LUri).LocalPath);

            // Validate that the request is for a DILX document
            if (String.Compare(Path.GetExtension(LUri), DilxUtility.CDilxExtension, true) != 0)
            {
                throw new ServerException(ServerException.Codes.UnknownExtension, Path.GetExtension(LUri));
            }

            // Read the DILX file
            using (FileStream LStream = new FileStream(LUri, FileMode.Open, FileAccess.Read, FileShare.Read))
            {
                StreamUtility.CopyStream(LStream, AContext.Response.OutputStream);
            }

            AContext.Response.End();
        }
示例#17
0
 public Stream Read(string imageID)
 {
     string fileName = BuildFileName(imageID);
     if (File.Exists(fileName))
         return File.OpenRead(fileName);
     else
     {
         FileStream fileStream = new FileStream(fileName, FileMode.CreateNew, FileAccess.ReadWrite);
         try
         {
             object tempValue = _identifiers[imageID];
             if (tempValue is String)
             {
                 using (DAE.Runtime.Data.Scalar scalar = (DAE.Runtime.Data.Scalar)_session.Pipe.RequestDocument((string)tempValue))
                     StreamUtility.CopyStream(scalar.OpenStream(), fileStream);
             }
             else
                 ((GetImageHandler)tempValue)(imageID, fileStream);
             fileStream.Position = 0;
             return fileStream;
         }
         catch
         {
             fileStream.Close();
             if (File.Exists(fileName))
                 File.Delete(fileName);
             throw;
         }
     }
 }
示例#18
0
        public void StreamUtility_ReadBoolean_2()
        {
            byte[]       buffer = new byte[0];
            MemoryStream stream = new MemoryStream(buffer);

            StreamUtility.ReadBoolean(stream);
        }
示例#19
0
        private List <Tuple <int, int> > WritePrimitives(EndianBinaryWriter writer)
        {
            List <Tuple <int, int> > outList = new List <Tuple <int, int> >();

            long start = writer.BaseStream.Position;

            foreach (Shape shape in Shapes)
            {
                foreach (Packet pack in shape.Packets)
                {
                    int offset = (int)(writer.BaseStream.Position - start);

                    foreach (Primitive prim in pack.Primitives)
                    {
                        prim.Write(writer, shape.Descriptor);
                    }

                    StreamUtility.PadStreamWithZero(writer, 32);

                    outList.Add(new Tuple <int, int>((int)((writer.BaseStream.Position - start) - offset), offset));
                }
            }

            return(outList);
        }
示例#20
0
 public void StreamUtility_HostToNetwork16_1()
 {
     byte[] array = { 1, 2 };
     StreamUtility.HostToNetwork16(array, 0);
     Assert.AreEqual(2, array[0]);
     Assert.AreEqual(1, array[1]);
 }
示例#21
0
        public void Write(EndianBinaryWriter writer)
        {
            long start = writer.BaseStream.Position;

            writer.Write("DRW1".ToCharArray());
            writer.Write(0); // Placeholder for section size
            writer.Write((short)WeightTypeCheck.Count);
            writer.Write((short)-1);

            writer.Write(20);                         // Offset to weight type bools, always 20
            writer.Write(20 + WeightTypeCheck.Count); // Offset to indices, always 20 + number of weight type bools

            foreach (bool bol in WeightTypeCheck)
            {
                writer.Write(bol);
            }

            foreach (int inte in Indices)
            {
                writer.Write((short)inte);
            }

            StreamUtility.PadStreamWithString(writer, 32);

            long end    = writer.BaseStream.Position;
            long length = (end - start);

            writer.Seek((int)start + 4, System.IO.SeekOrigin.Begin);
            writer.Write((int)length);
            writer.Seek((int)end, System.IO.SeekOrigin.Begin);
        }
示例#22
0
        public void StreamUtility_ReadExact_2()
        {
            byte[]       buffer = { 1, 2 };
            MemoryStream stream = new MemoryStream(buffer);

            StreamUtility.ReadExact(stream, 4);
        }
示例#23
0
        public void WriteImage()
        {
            WebSession = (Web.Session)Session["WebSession"];

            Response.ClearContent();
            Response.BufferOutput = false;

            string imageID = Request.QueryString["ImageID"];

            if ((imageID != null) && (imageID != String.Empty))
            {
                using (Stream stream = WebSession.ImageCache.Read(imageID))
                {
                    Response.AppendHeader(ContentLengthHeader, stream.Length.ToString());
                    StreamUtility.CopyStream(stream, Response.OutputStream);
                }
            }
            else
            {
                imageID = Request.QueryString["HandlerID"];
                if ((imageID != null) && (imageID != String.Empty))
                {
                    LoadImageHandler handler = WebSession.ImageCache.GetImageHandler(imageID);
                    if (handler != null)
                    {
                        handler(Context, imageID, Response.OutputStream);
                    }
                }
            }
        }
示例#24
0
        public void StreamUtility_ReadAsMuchAsPossible_3()
        {
            byte[]       buffer = { 1, 2, 3, 4 };
            MemoryStream stream = new MemoryStream(buffer);

            StreamUtility.ReadAsMuchAsPossible(stream, -3);
        }
示例#25
0
        /// <summary>
        /// Loads a dicom file, stopping at a certain tag
        /// </summary>
        /// <param name="file">Filename</param>
        /// <param name="stopTag">Tag to stop parsing at</param>
        /// <param name="options">DICOM read options</param>
        public DicomReadStatus Load(String file, DicomTag stopTag, DicomReadOptions options)
        {
            using (FileStream fs = File.OpenRead(file)) {
                fs.Seek(128, SeekOrigin.Begin);
                CheckFileHeader(fs);
                DicomStreamReader dsr = new DicomStreamReader(fs);

                _metainfo   = new DcmFileMetaInfo();
                dsr.Dataset = _metainfo;
                dsr.Read(DcmFileMetaInfo.StopTag, options | DicomReadOptions.FileMetaInfoOnly);

                if (_metainfo.TransferSyntax.IsDeflate)
                {
                    MemoryStream ms = StreamUtility.Deflate(fs, false);
                    dsr = new DicomStreamReader(ms);
                }

                _dataset    = new DcmDataset(_metainfo.TransferSyntax);
                dsr.Dataset = _dataset;
                DicomReadStatus status = dsr.Read(stopTag, options);

                fs.Close();

                return(status);
            }
        }
示例#26
0
        public void Dispose()
        {
            var success = false;

            try
            {
                string indexFileName = Path.Combine(_cachePath, IndexFileName);
                using (FileStream stream = new FileStream(indexFileName, FileMode.Create, FileAccess.Write, FileShare.None))
                {
                    _identifiers.Save(stream);
                }

                string cRC32FileName = Path.Combine(_cachePath, RC32FileName);
                using (FileStream stream = new FileStream(cRC32FileName, FileMode.Create, FileAccess.Write, FileShare.None))
                {
                    StreamUtility.SaveDictionary(stream, _cRC32s);
                }

                // Synchronize the index and CRC3 file times so that we know they were saved properly
                File.SetLastWriteTimeUtc(indexFileName, File.GetLastWriteTimeUtc(cRC32FileName));

                success = true;
            }
            finally
            {
                UnlockDirectory(success);
            }
        }
示例#27
0
        /// <summary>
        /// Gets a list of unique IDs for all messages.<br/>
        /// Messages marked as deleted are not listed.
        /// </summary>
        /// <returns>
        /// A list containing the unique IDs in sorted order from message number 1 and upwards.
        /// </returns>
        /// <exception cref="PopServerException">If the server did not accept the UIDL command</exception>
        public List <string> GetMessageUids()
        {
            AssertDisposed();

            if (State != ConnectionState.Transaction)
            {
                throw new InvalidUseException("Cannot get message IDs, when the user has not been authenticated yet");
            }

            // RFC Example:
            // C: UIDL
            // S: +OK
            // S: 1 whqtswO00WBw418f9t5JxYwZ
            // S: 2 QhdPYR:00WBw1Ph7x7
            // S: .      // this is the end

            SendCommand("UIDL");

            List <string> uids = new List <string>();

            string response;

            // Keep reading until multi-line ends with a "."
            while (!IsLastLineInMultiLineResponse(response = StreamUtility.ReadLineAsAscii(Stream)))
            {
                // Add the unique ID to the list
                uids.Add(response.Split(' ')[1]);
            }

            return(uids);
        }
示例#28
0
 private Image LoadImage(string imageExpression)
 {
     try
     {
         using (IDataValue imageData = FrontendSession.Pipe.RequestDocument(imageExpression))
         {
             var    streamCopy = new MemoryStream();
             Stream stream     = imageData.OpenStream();
             try
             {
                 StreamUtility.CopyStream(stream, streamCopy);
             }
             finally
             {
                 stream.Close();
             }
             return(Image.FromStream(streamCopy));
         }
     }
     catch (Exception exception)
     {
         Dataphoria.Warnings.AppendError(this, exception, true);
         // Don't rethrow
     }
     return(null);
 }
        /// <summary>
        /// Method that is able to find a specific MultiPart boundary in a Stream.<br/>
        /// The Stream passed should not be used for anything else then for looking for MultiPart boundaries
        /// <param name="stream">The stream to find the next MultiPart boundary in. Do not use it for anything else then with this method.</param>
        /// <param name="multiPartBoundary">The MultiPart boundary to look for. This should be found in the <see cref="ContentType"/> header</param>
        /// <param name="lastMultipartBoundaryFound">Is set to <see langword="true"/> if the next MultiPart boundary was indicated to be the last one, by having -- appended to it. Otherwise set to <see langword="false"/></param>
        /// </summary>
        /// <returns>The position of the first character of the line that contained MultiPartBoundary or -1 if no (more) MultiPart boundaries was found</returns>
        private static int FindPositionOfNextMultiPartBoundary(Stream stream, string multiPartBoundary, out bool lastMultipartBoundaryFound)
        {
            lastMultipartBoundaryFound = false;
            while (true)
            {
                // Get the current position. This is the first position on the line - no characters of the line will
                // have been read yet
                int currentPos = (int)stream.Position;

                // Read the line
                string line = StreamUtility.ReadLineAsAscii(stream);

                // If we kept reading until there was no more lines, we did not meet
                // the MultiPart boundary. -1 is then returned to describe this.
                if (line == null)
                {
                    return(-1);
                }

                // The MultiPart boundary is the MultiPartBoundary with "--" in front of it
                // which is to be at the very start of a line
                if (line.StartsWith("--" + multiPartBoundary, StringComparison.Ordinal))
                {
                    // Check if the found boundary was also the last one
                    lastMultipartBoundaryFound = line.StartsWith("--" + multiPartBoundary + "--", StringComparison.OrdinalIgnoreCase);
                    return(currentPos);
                }
            }
        }
        public void SaveFileFromStreamTest()
        {
            {
                var stream = GetStream(str);
                var file   = UnitTestHelper.RootPath + "SaveFileFromStreamTest.txt";
                StreamUtility.SaveFileFromStream(stream, file);

                Assert.IsTrue(File.Exists(file));
                Assert.IsTrue(UnitTestHelper.CheckKeywordsExist(file, str)); //检查内容已经被记录

                File.Delete(file);                                           //删除文件
            }

            #region 测试异步方法
            Task.Run(async() =>
            {
                var stream = GetStream(str);
                var file   = UnitTestHelper.RootPath + "SaveFileFromStreamTest.txt";
                await StreamUtility.SaveFileFromStreamAsync(stream, file);

                Assert.IsTrue(File.Exists(file));
                Assert.IsTrue(UnitTestHelper.CheckKeywordsExist(file, str)); //检查内容已经被记录

                File.Delete(file);                                           //删除文件
                Console.WriteLine("=== 异步完成 ===");
            }).GetAwaiter().GetResult();
            #endregion
        }