Inheritance: IDisposable
Exemplo n.º 1
1
		// Usually called when cloning images that need to have
		// not only the handle saved, but also the underlying stream
		// (when using MS GDI+ and IStream we must ensure the stream stays alive for all the life of the Image)
		internal Metafile (IntPtr ptr, Stream stream)
		{
			// under Win32 stream is owned by SD/GDI+ code
			if (GDIPlus.RunningOnWindows ())
				this.stream = stream;
			nativeObject = ptr;
		}
        public void Save(Stream output)
        {
            BinaryWriter writer = new BinaryWriter(output);

            writer.Write(this.version);
            writer.Write((int)0);
            writer.Write((int)0);

            // Double the string length since it's UTF16
            writer.Write((byte)(this.partName.Length * 2));
            MadScience.StreamHelpers.WriteStringUTF16(output, false, this.partName);

            writer.Write(this.blendType);
            this.blendTgi.Save(output);

            writer.Write((uint)this.geomBoneEntries.Count);
            for (int i = 0; i < this.geomBoneEntries.Count; i++)
            {
                this.geomBoneEntries[i].Save(output);
            }

            uint tgiOffset = (uint)output.Position - 8;
            // Why is this +12?  I dunno. :)
            this.keytable.size = 8;
            this.keytable.Save(output);
            output.Seek(4, SeekOrigin.Begin);
            writer.Write(tgiOffset);
            writer.Write(this.keytable.size);

            writer = null;
        }
Exemplo n.º 3
1
        public SourceText CreateText(Stream stream, Encoding defaultEncoding, CancellationToken cancellationToken = default(CancellationToken))
        {
            // this API is for a case where user wants us to figure out encoding from the given stream.
            // if defaultEncoding is given, we will use it if we couldn't figure out encoding used in the stream ourselves.
            Debug.Assert(stream != null);
            Debug.Assert(stream.CanSeek);
            Debug.Assert(stream.CanRead);

            if (defaultEncoding == null)
            {
                // Try UTF-8
                try
                {
                    return CreateTextInternal(stream, s_throwingUtf8Encoding, cancellationToken);
                }
                catch (DecoderFallbackException)
                {
                    // Try Encoding.Default
                    defaultEncoding = Encoding.Default;
                }
            }

            try
            {
                return CreateTextInternal(stream, defaultEncoding, cancellationToken);
            }
            catch (DecoderFallbackException)
            {
                return null;
            }
        }
Exemplo n.º 4
1
 protected void SetOutput(Stream stream, bool ownsStream, Encoding encoding)
 {
     _stream = stream;
     _ownsStream = ownsStream;
     _offset = 0;
     _encoding = encoding;
 }
Exemplo n.º 5
0
        /// <summary>
        /// Compute a hash from the content of a stream and restore the position.
        /// </summary>
        /// <remarks>
        /// Modified FNV Hash in C#
        /// http://stackoverflow.com/a/468084
        /// </remarks>
        internal static int ComputeHash(Stream stream)
        {
            System.Diagnostics.Debug.Assert(stream.CanSeek);

            unchecked
            {
                const int p = 16777619;
                var hash = (int)2166136261;

                var prevPosition = stream.Position;
                stream.Position = 0;

                var data = new byte[1024];
                int length;
                while((length = stream.Read(data, 0, data.Length)) != 0)
                {
                    for (var i = 0; i < length; i++)
                        hash = (hash ^ data[i]) * p;
                }

                // Restore stream position.
                stream.Position = prevPosition;

                hash += hash << 13;
                hash ^= hash >> 7;
                hash += hash << 3;
                hash ^= hash >> 17;
                hash += hash << 5;
                return hash;
            }
        }
Exemplo n.º 6
0
 public override void WriteProp(Stream output, bool array)
 {
     output.WriteF32(this.R);
     output.WriteF32(this.G);
     output.WriteF32(this.B);
     output.WriteF32(this.A);
 }
Exemplo n.º 7
0
 internal static byte[] ComputeFileHash(Stream fileStream)
 {
     using (var sha1 = new SHA1CryptoServiceProvider())
     {
         return sha1.ComputeHash(fileStream);
     }
 }
Exemplo n.º 8
0
        public static SpriteType DetectSpriteType(Stream s)
        {
            if (IsShpTD(s))
                return SpriteType.ShpTD;

            if (IsShpTS(s))
                return SpriteType.ShpTS;

            if (IsR8(s))
                return SpriteType.R8;

            if (IsTmpRA(s))
                return SpriteType.TmpRA;

            if (IsTmpTD(s))
                return SpriteType.TmpTD;

            if (IsTmpTS(s))
                return SpriteType.TmpTS;

            if (IsShpD2(s))
                return SpriteType.ShpD2;

            return SpriteType.Unknown;
        }
Exemplo n.º 9
0
 public override void ReadProp(Stream input, bool array)
 {
     this.R = input.ReadF32();
     this.G = input.ReadF32();
     this.B = input.ReadF32();
     this.A = input.ReadF32();
 }
Exemplo n.º 10
0
        public static dynamic[] Parse(Stream stream, Dictionary<int, string> fields)
        {
            var format = stream.Read<ulong>();
            stream.Position = 0;

            // DMsg format
            if (format == 0x00000067736D5F64)
            {
                return DMsgParser.Parse(stream, fields);
            }

            // Dialog format
            if ((format & 0x10000000) > 0 && format % 0x10000000 == (ulong) stream.Length - 4)
            {
                return DialogParser.Parse(stream, fields[0]);
            }

            // Auto-translate files (no specific format)
            if ((format & 0xFFFFFCFF) == 0x00010002)
            {
                return ATParser.Parse(stream, fields[0]);
            }

            throw new InvalidDataException("Unknown DAT format.");
        }
Exemplo n.º 11
0
 public static void WriteToStream(Image img, Stream stream)
 {
     IntPtr point = img.gdImageStructPtr;
     DLLImports.gdImageStruct gdImageStruct = Marshal.PtrToStructure<DLLImports.gdImageStruct>(point);
     var wrapper = new gdStreamWrapper(stream);
     DLLImports.gdImageJpegCtx(ref gdImageStruct, ref wrapper.IOCallbacks);
 }
        public CsvStateMachineReportGeneratorTest()
        {
            this.stateStream = new MemoryStream();
            this.transitionsStream = new MemoryStream();

            this.testee = new CsvStateMachineReportGenerator<States, Events>(this.stateStream, this.transitionsStream);
        }
Exemplo n.º 13
0
 public static XmlDocument StreamToXml(Stream stream)
 {
     var xmlDoc = new XmlDocument();
     var reader = new StreamReader(stream);
     xmlDoc.LoadXml(reader.ReadToEnd());
     return xmlDoc;
 }
Exemplo n.º 14
0
 public void Save(Stream s)
 {
     using (var w = new StreamWriter(s))
     {
         w.Write(JsonConvert.SerializeObject(this, Formatting.Indented));
     }
 }
Exemplo n.º 15
0
        static MemoryStream StreamToMemory(Stream input)
        {
            byte[] buffer = new byte[1024];
            int count = 1024;
            MemoryStream output;

            // build a new stream
            if (input.CanSeek)
            {
                output = new MemoryStream((int)input.Length);
            }
            else
            {
                output = new MemoryStream();
            }

            // iterate stream and transfer to memory stream
            do
            {
                count = input.Read(buffer, 0, count);
                if (count == 0)
                    break; // TODO: might not be correct. Was : Exit Do
                output.Write(buffer, 0, count);
            } while (true);

            // rewind stream
            output.Position = 0;

            // pass back
            return output;
        }
Exemplo n.º 16
0
            public override IOpcode ReadOpcode(Stream stream)
            {
                int contourCount = ReadUnsignedByte(stream);

                //extended count
                if (contourCount == 0)
                {
                    contourCount = 256 + ReadUnsignedShort(stream);
                }

                for (int i = 0; i < contourCount; i++)
                {
                    //each contour has a list of points
                    int pointsCount = ReadUnsignedByte(stream);

                    //points extended count
                    if (pointsCount == 0)
                    {
                        pointsCount = 256 + ReadUnsignedShort(stream);
                    }

                    //first vertex
                    ReadSignedShort(stream);
                    ReadSignedShort(stream);

                    for (int j = 0; j < pointsCount; j++)
                    {
                        //vertex(j)
                        ReadSignedShort(stream);
                        ReadSignedShort(stream);
                    }
                }

                return new DrawContourSetShort();
            }
Exemplo n.º 17
0
		internal LimitedInputStream(
			Stream inStream,
			int limit)
		{
			this._in = inStream;
			this._limit = limit;
		}
Exemplo n.º 18
0
 private static XmlSchemaSet LoadSchema(Stream xsd)
 {
     var reader = XmlReader.Create(xsd);
     var set = new XmlSchemaSet();
     set.Add(null, reader);
     return set;
 }
Exemplo n.º 19
0
        public void Read(Stream inputStream)
        {
            BinaryReader reader = new BinaryReader(inputStream, Encoding.UTF8, true);
            int magicNumber = reader.ReadInt32();
            int version = reader.ReadInt32(); // GZ 2, TPP 3
            int endianess = reader.ReadInt32(); // LE, BE
            int entryCount = reader.ReadInt32();
            int valuesOffset = reader.ReadInt32();
            int keysOffset = reader.ReadInt32();

            inputStream.Position = valuesOffset;
            Dictionary<int, LangEntry> offsetEntryDictionary = new Dictionary<int, LangEntry>();
            for (int i = 0; i < entryCount; i++)
            {
                int valuePosition = (int)inputStream.Position - valuesOffset;
                short valueConstant = reader.ReadInt16();
                Debug.Assert(valueConstant == 1);
                string value = reader.ReadNullTerminatedString();
                offsetEntryDictionary.Add(valuePosition, new LangEntry
                {
                    Value = value
                });
            }
            
            inputStream.Position = keysOffset;
            for (int i = 0; i < entryCount; i++)
            {
                uint key = reader.ReadUInt32();
                int offset = reader.ReadInt32();

                offsetEntryDictionary[offset].Key = key;
            }

            Entries = offsetEntryDictionary.Values.ToList();
        }
Exemplo n.º 20
0
		public override void OnPut(string key, Stream data, RavenJObject metadata)
		{
			if (key.StartsWith("Raven/")) // we don't deal with system attachment
				return;
			using (Database.DisableAllTriggersForCurrentThread())
			{
				var attachmentMetadata = GetAttachmentMetadata(key);
				if (attachmentMetadata != null)
				{
					RavenJArray history = new RavenJArray(metadata.Value<RavenJArray>(Constants.RavenReplicationHistory));
					metadata[Constants.RavenReplicationHistory] = history;

					if (attachmentMetadata.ContainsKey(Constants.RavenReplicationVersion) &&
						attachmentMetadata.ContainsKey(Constants.RavenReplicationSource))
					{
						history.Add(new RavenJObject
						{
							{Constants.RavenReplicationVersion, attachmentMetadata[Constants.RavenReplicationVersion]},
							{Constants.RavenReplicationSource, attachmentMetadata[Constants.RavenReplicationSource]}
						});
					}

					if (history.Length > Constants.ChangeHistoryLength)
					{
						history.RemoveAt(0);
					}
				}

				metadata[Constants.RavenReplicationVersion] = RavenJToken.FromObject(HiLo.NextId());
				metadata[Constants.RavenReplicationSource] = RavenJToken.FromObject(Database.TransactionalStorage.Id);
			}
		}
Exemplo n.º 21
0
 public List<Status> DeserializeStatusList(Stream stream)
 {
     XmlSerializer serializer = new XmlSerializer(
         typeof(List<Status>), 
         new XmlRootAttribute("statuses"));
     return (List<Status>)serializer.Deserialize(stream);
 }
Exemplo n.º 22
0
 public GenericBinaryFile(Stream stream)
 {
     _path = string.Empty;
     _data = new byte[stream.Length];
     stream.Read(_data, 0, (int)stream.Length);
     stream.Dispose();
 }
		public override ReadVetoResult AllowRead(string key, Stream data, RavenJObject metadata, ReadOperation operation)
		{
			RavenJToken value;
			if (metadata.TryGetValue("Raven-Delete-Marker", out value))
				return ReadVetoResult.Ignore;
			return ReadVetoResult.Allowed;
		}
Exemplo n.º 24
0
        private static string AddToArchive(string entryName, Stream inputStream, ZipArchive zipArchive, string hashName)
        {
            var entry = zipArchive.CreateEntry(entryName);

            HashAlgorithm hashAlgorithm = null;
            BinaryWriter zipEntryWriter = null;
            try
            {
                hashAlgorithm = HashAlgorithm.Create(hashName);
                zipEntryWriter = new BinaryWriter(entry.Open());

                var readBuffer = new byte[StreamReadBufferSize];
                int bytesRead;
                while ((bytesRead = inputStream.Read(readBuffer, 0, readBuffer.Length)) > 0)
                {
                    zipEntryWriter.Write(readBuffer, 0, bytesRead);
                    hashAlgorithm.TransformBlock(readBuffer, 0, bytesRead, readBuffer, 0);
                }
                hashAlgorithm.TransformFinalBlock(readBuffer, 0, 0);

                var hashHexStringBuilder = new StringBuilder();
                foreach (byte hashByte in hashAlgorithm.Hash)
                {
                    hashHexStringBuilder.Append(hashByte.ToString("x2"));
                }

                return hashHexStringBuilder.ToString();
            }
            finally
            {
                hashAlgorithm.SafeDispose();
                zipEntryWriter.SafeDispose();
            }
        }
Exemplo n.º 25
0
 public YmlEntry Parse(Stream stream)
 {
     var root = new YmlEntry("root");
     ICollection<YmlEntry> categories = root.Values;
     IEnumerable<string> rows = ReadAllRows(stream);
     YmlEntry parent = null;
     foreach (string row in rows)
     {
         if (row.StartsWith("\""))
         {
             string name = row.Substring(1, row.IndexOf("\"", 1) - 1);
             parent = new YmlEntry(name);
             categories.Add(parent);
         }
         else if (row.StartsWith("  "))
         {
             var nameValue = row.Trim().Split(':');
             var entry = new YmlEntry(nameValue[0]);
             var values = nameValue[1].Split('|');
             foreach (var value in values)
                 entry.AddValue(value.Trim());
             parent.Values.Add(entry);
         }
     }
     return root;
 }
Exemplo n.º 26
0
        public BundleFetchConnection(Transport transportBundle, Stream src)
        {
            transport = transportBundle;
            bin = new BufferedStream(src, IndexPack.BUFFER_SIZE);
            try
            {
                switch (readSignature())
                {
                    case 2:
                        readBundleV2();
                        break;

                    default:
                        throw new TransportException(transport.Uri, "not a bundle");
                }
            }
            catch (TransportException)
            {
                Close();
                throw;
            }
            catch (IOException err)
            {
                Close();
                throw new TransportException(transport.Uri, err.Message, err);
            }
        }
Exemplo n.º 27
0
 public static AcmeRegistration Load(Stream s)
 {
     using (var r = new StreamReader(s))
     {
         return JsonConvert.DeserializeObject<AcmeRegistration>(r.ReadToEnd());
     }
 }
        protected override byte[] ProcessRequest(string path, Stream request,
                IOSHttpRequest httpRequest, IOSHttpResponse httpResponse)
        {
            bool result = false;

            string[] p = SplitParams(path);

            if (p.Length > 0)
            {
                if (m_allowedTypes != AllowedRemoteDeleteTypes.None)
                {
                    string assetID = p[0];

                    AssetBase asset = m_AssetService.Get(assetID);
                    if (asset != null)
                    {
                        if (m_allowedTypes == AllowedRemoteDeleteTypes.All
                            || (int)(asset.Flags & AssetFlags.Maptile) != 0)
                        {
                            result = m_AssetService.Delete(assetID);
                        }
                        else
                        {
                            m_log.DebugFormat(
                                "[ASSET SERVER DELETE HANDLER]: Request to delete asset {0}, but type is {1} and allowed remote delete types are {2}",
                                assetID, (AssetFlags)asset.Flags, m_allowedTypes);
                        }
                    }
                }
            }

            XmlSerializer xs = new XmlSerializer(typeof(bool));
            return ServerUtils.SerializeResult(xs, result);
        }
Exemplo n.º 29
0
        public void Send(string toEmail, string subject, string body, Stream stream, string fileName)
        {
            SmtpClient smtp = new SmtpClient
            {
                Host = SmtpServer,
                Port = SmtpPort,
                EnableSsl = true,
                DeliveryMethod = SmtpDeliveryMethod.Network,
                UseDefaultCredentials = false,
                Credentials = new NetworkCredential(FromEmail, Password)
            };

            using (MailMessage message = new MailMessage(FromEmail, toEmail))
            {
                message.Subject = subject;
                message.Body = body;

                if (stream != null)
                {
                    Attachment attachment = new Attachment(stream, fileName);
                    message.Attachments.Add(attachment);
                }

                smtp.Send(message);
            }
        }
 public HttpResponseStreamWrapper(Stream stream, IRequest request)
 {
     this.OutputStream = stream;
     this.Request = request;
     this.Headers = new Dictionary<string, string>();
     this.Items = new Dictionary<string, object>();
 }
Exemplo n.º 31
0
        public static string postSync(string urlPost, string dados)
        {
            string Out = String.Empty;

            System.Net.WebRequest req = System.Net.WebRequest.Create(urlPost);
            try {
                req.Method      = "POST";
                req.Timeout     = 300000;
                req.ContentType = "application/x-www-form-urlencoded";
                byte[] sentData = Encoding.UTF8.GetBytes(dados);
                req.ContentLength = sentData.Length;
                using (System.IO.Stream sendStream = req.GetRequestStream()) {
                    sendStream.Write(sentData, 0, sentData.Length);
                    sendStream.Close();
                }
                WebResponse res           = req.GetResponse();
                IO.Stream   ReceiveStream = res.GetResponseStream();
                using (IO.StreamReader sr = new System.IO.StreamReader(ReceiveStream, Encoding.UTF8)) {
                    Char[] read  = new Char[256];
                    int    count = sr.Read(read, 0, 256);

                    while (count > 0)
                    {
                        String str = new String(read, 0, count);
                        Out  += str;
                        count = sr.Read(read, 0, 256);
                    }
                }
            } catch (ArgumentException ex) {
                Out = string.Format("HTTP_ERROR :: The second HttpWebRequest object has raised an Argument Exception as 'Connection' Property is set to 'Close' :: {0}", ex.Message);
            } catch (WebException ex) {
                Out = string.Format("HTTP_ERROR :: WebException raised! :: {0}", ex.Message);
            } catch (Exception ex) {
                Out = string.Format("HTTP_ERROR :: Exception raised! :: {0}", ex.Message);
            }

            return(Out);
        }
Exemplo n.º 32
0
 public static ThenType Deserialize(System.IO.Stream s)
 {
     return((ThenType)(Serializer.Deserialize(s)));
 }
Exemplo n.º 33
0
 public void Save(System.IO.Stream stream)
 {
 }
    protected void OnButtonCommand(object sender, CommandEventArgs e)
    {
        //Event handler for command button clicked
        try {
            //Change view to Viewer and reset to clear existing data
            Master.Viewer.Reset();

            //Initialize control values
            LocalReport report = Master.Viewer.LocalReport;
            report.DisplayName          = this.mTitle;
            report.EnableExternalImages = true;
            report.EnableHyperlinks     = true;
            EnterpriseService enterprise = new EnterpriseService();
            DataSet           ds         = new DataSet(this.mDSName);
            foreach (GridViewRow row in SelectedRows)
            {
                DataKey dataKey = (DataKey)this.grdPickups.DataKeys[row.RowIndex];
                DataSet _ds     = enterprise.FillDataset(this.mUSPName, mTBLName, new object[] { dataKey["PickupID"].ToString() });
                ds.Merge(_ds);
            }
            if (ds.Tables[mTBLName] == null)
            {
                ds.Tables.Add(mTBLName);
            }
            switch (e.CommandName)
            {
            case "Run":
                //Set local report and data source
                System.IO.Stream stream = Master.GetReportDefinition(this.mSource);
                report.LoadReportDefinition(stream);
                report.DataSources.Clear();
                report.DataSources.Add(new ReportDataSource(this.mDSName, ds.Tables[mTBLName]));
                report.SetParameters(new ReportParameter[] { new ReportParameter("PickupID", "0") });
                report.Refresh();
                if (!Master.Viewer.Enabled)
                {
                    Master.Viewer.CurrentPage = 1;
                }
                break;

            case "Data":
                //Set local export report and data source
                report.LoadReportDefinition(Master.CreateExportRdl(ds, this.mDSName, "RGXVMSQLR.TSORT"));
                report.DataSources.Clear();
                report.DataSources.Add(new ReportDataSource(this.mDSName, ds.Tables[mTBLName]));
                report.Refresh();
                break;

            case "Excel":
                //Create Excel mime-type page
                Response.ClearHeaders();
                Response.Clear();
                Response.Charset = "";
                Response.AddHeader("Content-Disposition", "inline; filename=LOccitaneCartonInfo.xls");
                Response.ContentType = "application/vnd.ms-excel";      //application/octet-stream";
                System.IO.StringWriter       sw = new System.IO.StringWriter();
                System.Web.UI.HtmlTextWriter hw = new System.Web.UI.HtmlTextWriter(sw);
                DataGrid dg = new DataGrid();
                dg.DataSource = ds.Tables[mTBLName];
                dg.DataBind();
                dg.RenderControl(hw);
                Response.Write(sw.ToString());
                Response.End();
                break;
            }
        }
        catch (Exception ex) { Master.ReportError(ex, 4); }
    }
Exemplo n.º 35
0
 public abstract void renderDocument(ITemplate template, IDictionary <string, object> values, ref System.IO.Stream outputStream);
Exemplo n.º 36
0
 public void Serialize(IO.Stream serializationStream, object graph)
 {
     throw new NotImplementedException();
 }
Exemplo n.º 37
0
 public object Deserialize(IO.Stream serializationStream)
 {
     throw new NotImplementedException();
 }
Exemplo n.º 38
0
 public void Write(System.IO.Stream stream)
 {
     using (Writer writer = new Writer(stream))
         this.Write(writer);
 }
Exemplo n.º 39
0
        //Thanks to https://github.com/GoldFarmer/rouge_sdf/blob/master/main.cpp for docs/structs
        public void Load(System.IO.Stream stream)
        {
            using (var reader = new FileReader(stream))
            {
                reader.ByteOrder = Syroot.BinaryData.ByteOrder.LittleEndian;

                //Read header
                Header = new SDFTOC_Header();
                Header.Read(reader);

                //Read first id
                var startId = new SDFTOC_ID(reader);

                //Check this flag
                byte Flag1 = reader.ReadByte();
                if (Flag1 != 0)
                {
                    byte[] unk = reader.ReadBytes(0x140);
                }

                if (Header.DataOffset != 0)
                {
                    reader.SeekBegin(Header.DataOffset + 0x51);

                    //Here is the compressed block. Check the magic first
                    uint magic = reader.ReadUInt32();
                    reader.Seek(-4, SeekOrigin.Current);

                    //Read and decompress the compressed block
                    //Contains file names and block info
                    DecompressNameBlock(magic, reader.ReadBytes((int)Header.CompressedSize), Header);

                    //Read last id
                    var endId = new SDFTOC_ID(reader);
                }
                else
                {
                    //Read first block
                    var block1 = reader.ReadInt32s((int)Header.Block1Count);

                    //Read ID blocks
                    var blockIds = new SDFTOC_ID[Header.Block1Count];
                    for (int i = 0; i < Header.Block1Count; i++)
                    {
                        blockIds[i] = new SDFTOC_ID(reader);
                    }

                    //Read block 2 (DDS headers)
                    block2Array = new SDFTOC_Block2[Header.Block2Count];
                    for (int i = 0; i < Header.Block2Count; i++)
                    {
                        block2Array[i] = new SDFTOC_Block2(reader, Header);
                    }

                    //Here is the compressed block. Check the magic first
                    uint magic = reader.ReadUInt32();
                    reader.Seek(-4, SeekOrigin.Current);

                    //Read and decompress the compressed block
                    //Contains file names and block info
                    DecompressNameBlock(magic, reader.ReadBytes((int)Header.CompressedSize), Header);

                    //Read last id
                    var endId = new SDFTOC_ID(reader);
                }

                Dictionary <string, int> Extensions = new Dictionary <string, int>();
                for (int i = 0; i < FileEntries.Count; i++)
                {
                    string ext = Utils.GetExtension(FileEntries[i].FileName);
                    if (!Extensions.ContainsKey(ext))
                    {
                        Extensions.Add(ext, 1);
                    }
                    else
                    {
                        Extensions[ext]++;
                    }
                }

                for (int i = 0; i < FileEntries.Count; i++)
                {
                    string ext = Utils.GetExtension(FileEntries[i].FileName);

                    if (Extensions[ext] > 10000 && ext != ".mmb")
                    {
                        FileEntries[i].CanLoadFile = false;
                    }

                    files.Add(FileEntries[i]);
                }

                List <string> FilteredExtensions = new List <string>();
                foreach (var ext in Extensions)
                {
                    if (ext.Value > 10000 && ext.Key != ".mmb")
                    {
                        FilteredExtensions.Add(ext.Key);
                    }
                }

                if (FilteredExtensions.Count > 0)
                {
                    MessageBox.Show($"File extensions have a very large amount of nodes used." +
                                    $" This will be filtered out to prevent slow booting. {ExtsToString(FilteredExtensions.ToArray())}");
                }
                //Remove unused data
                startId = null;
                FilteredExtensions.Clear();
                Extensions.Clear();
                //      block1 = new int[0];
                //     blockIds = new SDFTOC_ID[0];
                //     endId = null;
            }
        }
Exemplo n.º 40
0
        /// <summary>
        /// 转换为DataTable(内存流)
        /// </summary>
        public static DataTable TranslateToTable(System.IO.Stream stream)
        {
            ExcelUtils utils = new ExcelUtils(stream);

            return(utils.ToDataTable(0));
        }
Exemplo n.º 41
0
 /// <summary>
 ///   Create a <c>ZlibStream</c> using the specified <c>CompressionMode</c>
 ///   and the specified <c>CompressionLevel</c>, and explicitly specify
 ///   whether the stream should be left open after Deflation or Inflation.
 /// </summary>
 ///
 /// <remarks>
 ///
 /// <para>
 ///   This constructor allows the application to request that the captive
 ///   stream remain open after the deflation or inflation occurs.  By
 ///   default, after <c>Close()</c> is called on the stream, the captive
 ///   stream is also closed. In some cases this is not desired, for example
 ///   if the stream is a <see cref="System.IO.MemoryStream"/> that will be
 ///   re-read after compression.  Specify true for the <paramref
 ///   name="leaveOpen"/> parameter to leave the stream open.
 /// </para>
 ///
 /// <para>
 ///   When mode is <c>CompressionMode.Decompress</c>, the level parameter is
 ///   ignored.
 /// </para>
 ///
 /// </remarks>
 ///
 /// <example>
 ///
 /// This example shows how to use a ZlibStream to compress the data from a file,
 /// and store the result into another file. The filestream remains open to allow
 /// additional data to be written to it.
 ///
 /// <code>
 /// using (var output = System.IO.File.Create(fileToCompress + ".zlib"))
 /// {
 ///     using (System.IO.Stream input = System.IO.File.OpenRead(fileToCompress))
 ///     {
 ///         using (Stream compressor = new ZlibStream(output, CompressionMode.Compress, CompressionLevel.BestCompression, true))
 ///         {
 ///             byte[] buffer = new byte[WORKING_BUFFER_SIZE];
 ///             int n;
 ///             while ((n= input.Read(buffer, 0, buffer.Length)) != 0)
 ///             {
 ///                 compressor.Write(buffer, 0, n);
 ///             }
 ///         }
 ///     }
 ///     // can write additional data to the output stream here
 /// }
 /// </code>
 /// <code lang="VB">
 /// Using output As FileStream = File.Create(fileToCompress &amp; ".zlib")
 ///     Using input As Stream = File.OpenRead(fileToCompress)
 ///         Using compressor As Stream = New ZlibStream(output, CompressionMode.Compress, CompressionLevel.BestCompression, True)
 ///             Dim buffer As Byte() = New Byte(4096) {}
 ///             Dim n As Integer = -1
 ///             Do While (n &lt;&gt; 0)
 ///                 If (n &gt; 0) Then
 ///                     compressor.Write(buffer, 0, n)
 ///                 End If
 ///                 n = input.Read(buffer, 0, buffer.Length)
 ///             Loop
 ///         End Using
 ///     End Using
 ///     ' can write additional data to the output stream here.
 /// End Using
 /// </code>
 /// </example>
 ///
 /// <param name="stream">The stream which will be read or written.</param>
 ///
 /// <param name="mode">Indicates whether the ZlibStream will compress or decompress.</param>
 ///
 /// <param name="leaveOpen">
 /// true if the application would like the stream to remain open after
 /// inflation/deflation.
 /// </param>
 ///
 /// <param name="level">
 /// A tuning knob to trade speed for effectiveness. This parameter is
 /// effective only when mode is <c>CompressionMode.Compress</c>.
 /// </param>
 public ZlibStream(System.IO.Stream stream, CompressionMode mode, CompressionLevel level, bool leaveOpen)
 {
     _baseStream = new ZlibBaseStream(stream, mode, level, ZlibStreamFlavor.ZLIB, leaveOpen);
 }
Exemplo n.º 42
0
 /// <summary>
 ///   Create a <c>ZlibStream</c> using the specified <c>CompressionMode</c> and
 ///   the specified <c>CompressionLevel</c>.
 /// </summary>
 ///
 /// <remarks>
 ///
 /// <para>
 ///   When mode is <c>CompressionMode.Decompress</c>, the level parameter is ignored.
 ///   The "captive" stream will be closed when the <c>ZlibStream</c> is closed.
 /// </para>
 ///
 /// </remarks>
 ///
 /// <example>
 ///   This example uses a <c>ZlibStream</c> to compress data from a file, and writes the
 ///   compressed data to another file.
 ///
 /// <code>
 /// using (System.IO.Stream input = System.IO.File.OpenRead(fileToCompress))
 /// {
 ///     using (var raw = System.IO.File.Create(fileToCompress + ".zlib"))
 ///     {
 ///         using (Stream compressor = new ZlibStream(raw,
 ///                                                   CompressionMode.Compress,
 ///                                                   CompressionLevel.BestCompression))
 ///         {
 ///             byte[] buffer = new byte[WORKING_BUFFER_SIZE];
 ///             int n;
 ///             while ((n= input.Read(buffer, 0, buffer.Length)) != 0)
 ///             {
 ///                 compressor.Write(buffer, 0, n);
 ///             }
 ///         }
 ///     }
 /// }
 /// </code>
 ///
 /// <code lang="VB">
 /// Using input As Stream = File.OpenRead(fileToCompress)
 ///     Using raw As FileStream = File.Create(fileToCompress &amp; ".zlib")
 ///         Using compressor As Stream = New ZlibStream(raw, CompressionMode.Compress, CompressionLevel.BestCompression)
 ///             Dim buffer As Byte() = New Byte(4096) {}
 ///             Dim n As Integer = -1
 ///             Do While (n &lt;&gt; 0)
 ///                 If (n &gt; 0) Then
 ///                     compressor.Write(buffer, 0, n)
 ///                 End If
 ///                 n = input.Read(buffer, 0, buffer.Length)
 ///             Loop
 ///         End Using
 ///     End Using
 /// End Using
 /// </code>
 /// </example>
 ///
 /// <param name="stream">The stream to be read or written while deflating or inflating.</param>
 /// <param name="mode">Indicates whether the ZlibStream will compress or decompress.</param>
 /// <param name="level">A tuning knob to trade speed for effectiveness.</param>
 public ZlibStream(System.IO.Stream stream, CompressionMode mode, CompressionLevel level)
     : this(stream, mode, level, false)
 {
 }
Exemplo n.º 43
0
 public static NumTrigNumType111 Deserialize(System.IO.Stream s)
 {
     return((NumTrigNumType111)(Serializer.Deserialize(s)));
 }
Exemplo n.º 44
0
        /// <summary>
        /// Used by the controlAPI to get a snapshot. We act like a web server.
        /// I assume that the snapshots are taken infrequently. Hopefully, this API will not be used at 30 fps
        /// (because of the PNG compression overhead). Note that the overhead is onerous when taking SNAPshots frequently might make sense
        /// </summary>
        /// <param name="result"></param>
        public void sendScreenShot(IAsyncResult result)
        {
            // Take the request off the queue and prepare the webserver to accept further requests
            HttpListener        listener = (HttpListener)result.AsyncState;
            HttpListenerContext context  = listener.EndGetContext(result);
            HttpListenerRequest request  = context.Request;

            String c = request.Url.LocalPath;
            int    width = _bitmapWidth, height = _bitmapHeight;

            if (request.Url.Query.Length > 0)
            {
                String   cmd        = request.Url.Query.Substring(1).ToUpper();
                char[]   delimiters = { '=', '&' };
                String[] words      = cmd.Split(delimiters);

                // Specify width to scale the screen snapshot
                if (words.Length == 2)
                {
                    if ((words[0].Equals("WIDTH")))
                    {
                        width = Convert.ToInt32(words[1]);
                        if (width <= 0)
                        {
                            width = _bitmapWidth;
                        }
                        else
                        {
                            height = (int)((float)_bitmapHeight * (float)width / (float)_bitmapWidth);
                        }
                    }
                }

                if (words.Length == 4)
                {
                    if ((words[0].Equals("WIDTH")))
                    {
                        width = Convert.ToInt32(words[1]);
                        if (width <= 0)
                        {
                            width = _bitmapWidth;
                        }
                        else
                        {
                            height = (int)((float)_bitmapHeight * (float)width / (float)_bitmapWidth);
                        }
                    }
                    else
                    {
                        if ((words[2].Equals("WIDTH")))
                        {
                            width = Convert.ToInt32(words[3]);
                            if (width <= 0)
                            {
                                width = _bitmapWidth;
                            }
                            else
                            {
                                height = (int)((float)_bitmapHeight * (float)width / (float)_bitmapWidth);
                            }
                        }
                    }
                }
            }

            // Fillscreen() is not needed while actively streaming
            // when there are no players, screen is out of date and refreshed on a new connect.
            // Since snapshot is asynchronous to that logic, we force a new fill
            fillScreen();

            // Convert the screen to a PNG image
            Bitmap bmp = new Bitmap(_bitmapWidth, _bitmapHeight, PixelFormat.Format32bppRgb);

            //Create a BitmapData and Lock all pixels to be written
            BitmapData bmpData = bmp.LockBits(new System.Drawing.Rectangle(0, 0, bmp.Width, bmp.Height),
                                              ImageLockMode.WriteOnly, bmp.PixelFormat);

            //Copy the data from the byte array into BitmapData.Scan0
            System.Runtime.InteropServices.Marshal.Copy(screen, 0, bmpData.Scan0, screen.Length);

            //Unlock the pixels
            bmp.UnlockBits(bmpData);

            if (Program.maskValid == true)
            {
                using (Graphics g = Graphics.FromImage(bmp)) {
                    g.CompositingMode = System.Drawing.Drawing2D.CompositingMode.SourceCopy;
                    Brush blackBrush = new SolidBrush(Color.Black);

                    // Create array of rectangles.
                    RectangleF[] rects = { new RectangleF(0.0F,                                                            0.0F, _bitmapWidth,                                     Program.maskY),
                                           new RectangleF(0.0F,                              Program.maskY,                      Program.maskX,                                    Program.maskHeight),
                                           new RectangleF(Program.maskX + Program.maskWidth, Program.maskY,                      _bitmapWidth - Program.maskX - Program.maskWidth, Program.maskHeight),
                                           new RectangleF(0.0F,                              Program.maskY + Program.maskHeight, _bitmapWidth,                                     _bitmapHeight - Program.maskY - Program.maskHeight) };

                    // Draw rectangles to screen.
                    g.FillRectangles(blackBrush, rects);
                }
            }

            if (width != _bitmapWidth)
            {
                Size   newsz   = new Size(width, height);
                Bitmap resized = new Bitmap(bmp, newsz);
                bmp.Dispose();
                bmp = resized;
            }

            byte[] buffer = null;
            try {
                using (MemoryStream stream = new MemoryStream()) {
                    bmp.Save(stream, ImageFormat.Png);
                    buffer = stream.ToArray();
                }
                context.Response.ContentType     = "image/png";
                context.Response.ContentLength64 = buffer.Length;
                // context.Response.Headers.Add("Expires", "Sat, 1 Jan 2011 01:01:01 GMT");
            } catch {
                context.Response.StatusCode = (int)HttpStatusCode.InternalServerError;
            }
            context.Response.KeepAlive = false;

            System.IO.Stream output = context.Response.OutputStream;
            try {
                output.Write(buffer, 0, buffer.Length);
                output.Close();
            } catch (Exception) {
                // Oh well
            }

            // Ready to receive the next request
            listener.BeginGetContext(sendScreenShot, listener);
        }
Exemplo n.º 45
0
 /// <summary>
 ///   Create a <c>ZlibStream</c> using the specified <c>CompressionMode</c>, and
 ///   explicitly specify whether the captive stream should be left open after
 ///   Deflation or Inflation.
 /// </summary>
 ///
 /// <remarks>
 ///
 /// <para>
 ///   When mode is <c>CompressionMode.Compress</c>, the <c>ZlibStream</c> will use
 ///   the default compression level.
 /// </para>
 ///
 /// <para>
 ///   This constructor allows the application to request that the captive stream
 ///   remain open after the deflation or inflation occurs.  By default, after
 ///   <c>Close()</c> is called on the stream, the captive stream is also
 ///   closed. In some cases this is not desired, for example if the stream is a
 ///   <see cref="System.IO.MemoryStream"/> that will be re-read after
 ///   compression.  Specify true for the <paramref name="leaveOpen"/> parameter to leave the stream
 ///   open.
 /// </para>
 ///
 /// <para>
 /// See the other overloads of this constructor for example code.
 /// </para>
 ///
 /// </remarks>
 ///
 /// <param name="stream">The stream which will be read or written. This is called the
 /// "captive" stream in other places in this documentation.</param>
 /// <param name="mode">Indicates whether the ZlibStream will compress or decompress.</param>
 /// <param name="leaveOpen">true if the application would like the stream to remain
 /// open after inflation/deflation.</param>
 public ZlibStream(System.IO.Stream stream, CompressionMode mode, bool leaveOpen)
     : this(stream, mode, CompressionLevel.Default, leaveOpen)
 {
 }
Exemplo n.º 46
0
 public Model.ProvisioningTemplate ToProvisioningTemplate(System.IO.Stream template)
 {
     return(this.ToProvisioningTemplate(template, null));
 }
Exemplo n.º 47
0
 /// <summary>
 /// Create a <c>ZlibStream</c> using the specified <c>CompressionMode</c>.
 /// </summary>
 /// <remarks>
 ///
 /// <para>
 ///   When mode is <c>CompressionMode.Compress</c>, the <c>ZlibStream</c>
 ///   will use the default compression level. The "captive" stream will be
 ///   closed when the <c>ZlibStream</c> is closed.
 /// </para>
 ///
 /// </remarks>
 ///
 /// <example>
 /// This example uses a <c>ZlibStream</c> to compress a file, and writes the
 /// compressed data to another file.
 /// <code>
 /// using (System.IO.Stream input = System.IO.File.OpenRead(fileToCompress))
 /// {
 ///     using (var raw = System.IO.File.Create(fileToCompress + ".zlib"))
 ///     {
 ///         using (Stream compressor = new ZlibStream(raw, CompressionMode.Compress))
 ///         {
 ///             byte[] buffer = new byte[WORKING_BUFFER_SIZE];
 ///             int n;
 ///             while ((n= input.Read(buffer, 0, buffer.Length)) != 0)
 ///             {
 ///                 compressor.Write(buffer, 0, n);
 ///             }
 ///         }
 ///     }
 /// }
 /// </code>
 /// <code lang="VB">
 /// Using input As Stream = File.OpenRead(fileToCompress)
 ///     Using raw As FileStream = File.Create(fileToCompress &amp; ".zlib")
 ///     Using compressor As Stream = New ZlibStream(raw, CompressionMode.Compress)
 ///         Dim buffer As Byte() = New Byte(4096) {}
 ///         Dim n As Integer = -1
 ///         Do While (n &lt;&gt; 0)
 ///             If (n &gt; 0) Then
 ///                 compressor.Write(buffer, 0, n)
 ///             End If
 ///             n = input.Read(buffer, 0, buffer.Length)
 ///         Loop
 ///     End Using
 ///     End Using
 /// End Using
 /// </code>
 /// </example>
 ///
 /// <param name="stream">The stream which will be read or written.</param>
 /// <param name="mode">Indicates whether the ZlibStream will compress or decompress.</param>
 public ZlibStream(System.IO.Stream stream, CompressionMode mode)
     : this(stream, mode, CompressionLevel.Default, false)
 {
 }
Exemplo n.º 48
0
        /// <summary>
        /// 转换为DataTable(内存流+表名)
        /// </summary>
        public static DataTable TranslateToTable(System.IO.Stream stream, string sheetName)
        {
            ExcelUtils utils = new ExcelUtils(stream);

            return(utils.ToDataTable(sheetName));
        }
Exemplo n.º 49
0
        private IList <PakAnass> GetDataLocalUploadExcel(HttpPostedFileBase file,
                                                         IList <string> errMesgs)
        {
            HSSFWorkbook hssfwb = null;

            using (System.IO.Stream file2 = file.InputStream)
            {
                hssfwb = new HSSFWorkbook(file2);
            }

            if (hssfwb == null)
            {
                throw new ArgumentException("Cannot create Workbook object from excel file" + file.FileName);
            }

            IRow             row         = null;
            ICell            cell        = null;
            IList <PakAnass> listPakanas = new List <PakAnass>();

            int  indexRow       = DATA_ROW_INDEX_START;
            bool isAllCellEmpty = true;
            bool isBreak        = false;

            ISheet sheet = hssfwb.GetSheetAt(0);

            for (indexRow = DATA_ROW_INDEX_START; indexRow <= sheet.LastRowNum; indexRow++)
            {
                isAllCellEmpty = true;
                isBreak        = false;
                row            = sheet.GetRow(indexRow);
                row            = sheet.GetRow(indexRow);
                if (row != null) //null is when the row only contains empty celss
                {
                    PakAnass Pak = new PakAnass();

                    //org_code
                    try
                    {
                        cell = row.GetCell(0);
                        if (cell == null || cell.CellType == CellType.BLANK)
                        {
                            cell = row.GetCell(1);
                            if (indexRow != DATA_ROW_INDEX_START && (cell == null || cell.CellType == CellType.BLANK))
                            {
                                break;
                            }
                            else
                            {
                                errMesgs.Add(string.Format("org_code row {0} is empty", indexRow + 1));
                                isAllCellEmpty = true;
                            }
                        }
                        else
                        {
                            if (cell.CellType == CellType.NUMERIC)
                            {
                                Pak.org_code   = Convert.ToString(cell.NumericCellValue);
                                isAllCellEmpty = false;
                            }
                            else if (cell.CellType == CellType.STRING)
                            {
                                Pak.org_code   = cell.StringCellValue;
                                isAllCellEmpty = false;
                            }
                            else
                            {
                                errMesgs.Add(string.Format("org_code row {0} is incorrect Format", indexRow + 1));
                                isAllCellEmpty = true;
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        errMesgs.Add(string.Format("Unable To get value of PakAnas No at row {0}, Error Mesg : {1}",
                                                   indexRow + 1, ex.Message));
                    }

                    //org_name
                    try
                    {
                        cell = row.GetCell(1);
                        if (cell.CellType == CellType.BLANK)
                        {
                            errMesgs.Add(string.Format("org_name row {0} is empty", indexRow + 1));
                            isAllCellEmpty = true;
                        }
                        else
                        {
                            if (cell.CellType == CellType.STRING)
                            {
                                Pak.org_name   = cell.StringCellValue;
                                isAllCellEmpty = false;
                            }
                            else
                            {
                                errMesgs.Add(string.Format("org_name row {0} is Incorrect Format", indexRow + 1));
                                isAllCellEmpty = true;
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        errMesgs.Add(string.Format("Unable to get value of org_name at row {0}, Error Mesg : {1}",
                                                   indexRow + 1, ex.Message));
                        isAllCellEmpty = true;
                    }

                    listPakanas.Add(Pak);
                }
            }
            return(listPakanas);
        }
Exemplo n.º 50
0
        public void ProcessRequest(HttpContext context)
        {
            try
            {
                string       Code   = context.Request.Form["customCode"];
                WebClient    web    = new WebClient();
                StreamReader reader = null;
                //获取公司服务地址
                string getCompanyAddress1 = System.Web.Configuration.WebConfigurationManager.AppSettings["getCompanyAddress1"].ToString();
                string getCompanyAddress2 = System.Web.Configuration.WebConfigurationManager.AppSettings["getCompanyAddress2"].ToString();
                web = new WebClient();
                getCompanyAddress1 = getCompanyAddress1 + Code;
                getCompanyAddress2 = getCompanyAddress2 + Code;
                //远程获取公司信息
                System.IO.Stream getCompany1 = web.OpenRead(getCompanyAddress1);
                System.IO.Stream getCompany2 = web.OpenRead(getCompanyAddress2);

                reader = new StreamReader(getCompany1);
                string strCompany1 = reader.ReadToEnd();
                getCompany1.Close();

                reader = new StreamReader(getCompany2);
                string strCompany2 = reader.ReadToEnd();
                getCompany2.Close();

                reader.Dispose();

                if (!strCompany1.Equals(""))
                {
                    try
                    {
                        //转换为公司对像
                        JsonSerializer       serializer = new JsonSerializer();
                        StringReader         sr         = new StringReader(strCompany1);
                        PageBase.CompanyData obj        = serializer.Deserialize <PageBase.CompanyData>(new JsonTextReader(sr));
                        context.Response.Write(JsonConvert.SerializeObject(new Data("", obj.FULL_NAME)));
                    }
                    catch (Exception ex)
                    {
                        context.Response.Write(JsonConvert.SerializeObject(new Data("转换企业对像失败:" + strCompany1 + "|" + ex.Message.ToString(), "")));
                    }
                }
                else if (!strCompany2.Equals(""))
                {
                    try
                    {
                        //转换为公司对像
                        JsonSerializer       serializer = new JsonSerializer();
                        StringReader         sr         = new StringReader(strCompany2);
                        PageBase.CompanyData obj        = serializer.Deserialize <PageBase.CompanyData>(new JsonTextReader(sr));
                        context.Response.Write(JsonConvert.SerializeObject(new Data("", obj.FULL_NAME)));
                    }
                    catch (Exception ex)
                    {
                        context.Response.Write(JsonConvert.SerializeObject(new Data("转换企业对像失败:" + strCompany2 + "|" + ex.Message.ToString(), "")));
                    }
                }
                else
                {
                    context.Response.Write(JsonConvert.SerializeObject(new Data("获取公司信息失败!", "")));
                }
            }
            catch (Exception ex)
            {
                context.Response.Write(JsonConvert.SerializeObject(new Data(ex.Message.ToString(), "")));
            }
        }
Exemplo n.º 51
0
 public static MonoSymbolFile ReadSymbolFile(ModuleDefinition module, System.IO.Stream stream)
 {
     return(new MonoSymbolFile(stream, module));
 }
Exemplo n.º 52
0
 public static SectionBaseType Deserialize(System.IO.Stream s)
 {
     return((SectionBaseType)(Serializer.Deserialize(s)));
 }
Exemplo n.º 53
0
 public static hexBinary_DEtype Deserialize(System.IO.Stream s)
 {
     return((hexBinary_DEtype)(Serializer.Deserialize(s)));
 }
Exemplo n.º 54
0
        private static void Main(string[] args)
        {
            if (!HttpListener.IsSupported)
            {
                Console.WriteLine("A more recent Windows version is required to use the HttpListener class.");
                return;
            }

            // Create a listener.
            HttpListener listener = new HttpListener();

            // Trap Ctrl-C and exit
            Console.CancelKeyPress += delegate
            {
                listener.Stop();
                System.Environment.Exit(0);
            };

            // Add the prefixes.
            if (args.Length != 0)
            {
                foreach (string s in args)
                {
                    listener.Prefixes.Add(s);
                    // don't forget to authorize access to the TCP/IP addresses localhost:xxxx and localhost:yyyy
                    // with netsh http add urlacl url=http://localhost:xxxx/ user="******"
                    // and netsh http add urlacl url=http://localhost:yyyy/ user="******"
                    // user="******" is language dependent, use user=Everyone in english
                }
            }
            else
            {
                Console.WriteLine("Syntax error: the call must contain at least one web server url as argument");
            }
            listener.Start();
            foreach (string s in args)
            {
                Console.WriteLine("Listening for connections on " + s);
            }

            while (true)
            {
                // Note: The GetContext method blocks while waiting for a request.
                HttpListenerContext context = listener.GetContext();
                HttpListenerRequest request = context.Request;

                string documentContents;
                using (Stream receiveStream = request.InputStream)
                {
                    using (StreamReader readStream = new StreamReader(receiveStream, Encoding.UTF8))
                    {
                        documentContents = readStream.ReadToEnd();
                    }
                }
                Console.WriteLine($"Received request for {request.Url}");
                Console.WriteLine(documentContents);

                // Obtain a response object.
                HttpListenerResponse response = context.Response;
                NameValueCollection  headers  = context.Request.Headers;

                Header header = new Header(request.Headers);

                Console.WriteLine(header);


                // Construct a response.
                string responseString = "<HTML><BODY> Hello world!</BODY></HTML>";
                byte[] buffer         = System.Text.Encoding.UTF8.GetBytes(responseString);
                // Get a response stream and write the response to it.
                response.ContentLength64 = buffer.Length;
                System.IO.Stream output = response.OutputStream;
                output.Write(buffer, 0, buffer.Length);
                // You must close the output stream.
                output.Close();
            }
            // Httplistener neither stop ...
            // listener.Stop();
        }
Exemplo n.º 55
0
 public static byte_Stype Deserialize(System.IO.Stream s)
 {
     return((byte_Stype)(Serializer.Deserialize(s)));
 }
Exemplo n.º 56
0
 override public void Load(System.IO.Stream fs, Plane sblock)
 {
     base.Load(fs, sblock);
     lodgersCount = (byte)fs.ReadByte();
 }
Exemplo n.º 57
0
 public override void Deserialise(System.IO.Stream inStr)
 {
     Deserialise(new BinaryReader(inStr));
 }