C# BinaryReader.Read方法代码示例

	public void Load(int Index){
			MemoryMappedFileSecurity CustomSecurity = new MemoryMappedFileSecurity();
CustomSecurity.AddAccessRule(new System.Security.AccessControl.AccessRule<MemoryMappedFileRights>("everyone", MemoryMappedFileRights.FullControl, System.Security.AccessControl.AccessControlType
.Allow));
			using(MemoryMappedFile mmf = MemoryMappedFile.CreateOrOpen("bits", (long)Math.Ceiling(Length/8.0), MemoryMappedFileAccess.ReadWriteExecute, MemoryMappedFileOptions.None, CustomSecurity, System.IO.HandleInheritability.Inheritable)){
			using (MemoryMappedViewStream stream = mmf.CreateViewStream())
           		{
				int Amount = (int)Math.Ceiling((double)(Length/Int32.MaxValue));
				int Remainder = (int)(Length%Int32.MaxValue);
				int length = (int)(Amount==Index?Math.Ceiling(Remainder/8.0):Math.Ceiling(Int32.MaxValue/8.0));
				byte[] buffer = BitArrayToByteArray(LoadedArray,0,LoadedArray.Length);
				stream.Position=(long)Math.Ceiling((Int32.MaxValue/8.0))*LoadedArrayIndex;
                		BinaryWriter writer = new BinaryWriter(stream);
				writer.Write(buffer);
				stream.Position=0;//(long)Math.Ceiling((Int32.MaxValue/8.0))*Index;
				BinaryReader reader = new BinaryReader(stream);
				buffer = new byte[(int)Math.Ceiling((Int32.MaxValue/8.0))];
				try{reader.Read(buffer,(int)Math.Ceiling((Int32.MaxValue/8.0))*Index,(int)Math.Ceiling((Int32.MaxValue/8.0)));} catch{LoadedArray = new BitArray((int)(length*8.0));}
           		}
			}
			//int ElementIndex = (int)Math.Floor((double)(T/Int32.MaxValue));
			//int Index = (int)(T%Int32.MaxValue);
			//Elements[ElementIndex][Index]=value;
		//}
	}

	/**
	 * Gets the next message from an input stream. Crudely, this method keeps
	 * reading lines from the stream until it finds one that contains the string
	 * "</message>". It ignores lines with elements called "<trace>"
	 * or "</trace>". It returns null if it does not read anything.
	 * 
	 * @param dis
	 *          A data input stream, corresponding to some opened file
	 * @return A string corresponding to the next message, or null if no message
	 *         could be read
	 */
	private static string getNextMessage(BinaryReader br)
	{
		string message = "";
		
		try
		{
			while (br.Read() != 0)
			{
				string line = br.ReadString();
				
				line = line.Trim();
				
				if (line.IndexOf("<Trace>") != -1 || 
					line.IndexOf("</Trace>") != -1)
				{
					continue;
				}
				
				message += line;
				
				if (line.IndexOf("</Event>") != -1)
				{
					break;
				}
			}
		}
		
		catch (IOException o)
		{
			System.Diagnostics.Debug.Print (o.ToString());
			return null;
		}
		
		return message;
	}

    public void ReadMp3TagFromFile(string path)
    {
        var buffer = new char[ ID3TagLength ];

        // Open file
        using ( var binReader = new BinaryReader( File.Open( path, FileMode.Open ) ) ) {
            // Take last 128 bytes in
            binReader.BaseStream.Seek( -ID3TagLength, SeekOrigin.End );
            int bytesRead = binReader.Read( buffer, 0, ID3TagLength );

            if ( bytesRead == ID3TagLength ) {
                string tagMark = new string( buffer, 0, 3 );

                if ( tagMark == ID3TagMark ) {
                    // Read the ID3 tag data
                    edTitle.Text = ( new string( buffer, 3, 30 ) ).Trim();
                    edAuthor.Text = ( new string( buffer, 33, 30 ) ).Trim();
                    edAlbum.Text = ( new string( buffer, 63, 30 ) ).Trim();
                    edYear.Text =  ( new string( buffer, 93, 4 ) ).Trim();
                }
            }
        }

        return;
    }

                public void TestStreams()
                {
                    Variant dict = new Variant(Variant.EnumType.Dictionary);
                    dict.Add("key1", new Variant("value1"));
                    dict.Add("key2", new Variant("value2"));

                    Variant input = new Variant(Variant.EnumType.List);
                    for (int i = 0; i < 10000; ++i)
                    {
                        input.Add(dict);
                    }

                    System.IO.MemoryStream istream = new System.IO.MemoryStream();
                    using(BinaryWriter writer = new BinaryWriter(istream))
                    {
                        writer.Write(input);
                    }

                    Variant output;
                    System.IO.MemoryStream ostream = new System.IO.MemoryStream(istream.GetBuffer());
                    using (BinaryReader reader = new BinaryReader(ostream))
                    {
                        output = reader.Read();
                    }

                    Assert.True(input.Equals(output));
                }

 public static void Main()
 {
     char[] e=new char[20000];
     var b=new BinaryReader(new BufferedStream(Console.OpenStandardInput()));
     var h=b.Read(e,0,20000);
     var z=(new S(e,0,h)).Split(null);
     var d=new System.Collections.Generic.Dictionary<S,S>();
     S s="",t=s,r,x;
     int i,j;
     if(z[0]=="6")
         C.Write("fdkjnvqaqvnjkdf");
     else if(z[0]=="1")
         C.Write(z[1]);
     else if(z[0]=="7")
         for(i=0;i<7;i++)
             C.Write(z[1]);
     else
     {
         Array.Sort(z,1,z.Length-1);
         for(i=1;i<z.Length;i++)
         {
             x=z[i];
             r=new S(x.Reverse().ToArray());
             j=Array.IndexOf(z,r,i+1);
             if(j>0)
             {
                 s+=x;
                 t=r+t;
                 z[i]=z[j]="";
             }
         }
         C.Write(s+t);
     }
 }

 public static Variant FromBytes(byte[] bytes, BinaryMode mode, IVariantObjectFactory factory)
 {
     using (MemoryStream ms = new MemoryStream(bytes))
     {
         BinaryReader reader = new BinaryReader(ms, mode, factory);
         return reader.Read();
     }
 }

    public static double[][] Read(string fileName, out int sampFreq)
    {
        using (FileStream fs = new FileStream(fileName, FileMode.Open, FileAccess.Read))
        {
            using (BinaryReader br = new BinaryReader(fs))
            {
                if (br.ReadInt32() != RiffHeader)
                {
                    throw new Exception("WAVファイルじゃない＼(^o^)／");
                }
                br.ReadInt32();
                if (br.ReadInt32() != WaveHeader)
                {
                    throw new Exception("WAVファイルじゃない＼(^o^)／");
                }

                while (br.ReadInt32() != FmtHeader)
                {
                    br.BaseStream.Seek(br.ReadInt32() + 1 >> 1 << 1, SeekOrigin.Current);
                }

                int numChannels;
                {
                    byte[] chunk = new byte[br.ReadInt32()];
                    br.Read(chunk, 0, chunk.Length);
                    ReadFmtChunk(chunk, out numChannels, out sampFreq);
                    if ((chunk.Length & 1) > 0) br.ReadByte();
                }

                while (br.ReadInt32() != DataHeader)
                {
                    br.BaseStream.Seek(br.ReadInt32() + 1 >> 1 << 1, SeekOrigin.Current);
                }

                {
                    byte[] chunk = new byte[br.ReadInt32()];
                    br.Read(chunk, 0, chunk.Length);
                    return ReadDataChunk(chunk, numChannels);
                }
            }
        }
    }

    public byte[] ConversionImagen(string nombrearchivo)
    {
        FileStream fs = new FileStream(nombrearchivo, FileMode.Open);

        BinaryReader br = new BinaryReader(fs);
        byte[] imagen = new byte[(int)fs.Length];
        br.Read(imagen, 0, (int)fs.Length);
        br.Close();
        fs.Close();
        return imagen;
    }

    public ItemQuote decode(Stream wire)
    {
        BinaryReader src = new BinaryReader(new BufferedStream(wire));

        long itemNumber = IPAddress.NetworkToHostOrder(src.ReadInt64());
        int quantity = IPAddress.NetworkToHostOrder(src.ReadInt32());
        int unitPrice = IPAddress.NetworkToHostOrder(src.ReadInt32());
        byte flags = src.ReadByte();

        int stringLength = src.Read(); // Returns an unsigned byte as an int
        if (stringLength == -1)
          throw new EndOfStreamException();
        byte[] stringBuf = new byte[stringLength];
        src.Read(stringBuf, 0, stringLength);
        String itemDesc = encoding.GetString(stringBuf);

        return new ItemQuote(itemNumber,itemDesc, quantity, unitPrice,
          ((flags & ItemQuoteBinConst.DISCOUNT_FLAG) == ItemQuoteBinConst.DISCOUNT_FLAG),
          ((flags & ItemQuoteBinConst.IN_STOCK_FLAG) == ItemQuoteBinConst.IN_STOCK_FLAG));
    }

	public byte Read(long T,MemoryMappedViewStream stream){

				byte[] buffer = new byte[1];
                		BinaryReader reader = new BinaryReader(stream);
     				try{reader.Read(buffer,(int)Math.Floor(T/8.0),1);}
				catch{return default(byte);}
				
				return buffer[0];
           		
			
	}

	protected void Page_Load (object sender, EventArgs e)
	{
		// Console.WriteLine ("MoonLogProvider");
		try {
			string filename, directory, path;
			byte [] bytes = new byte [1024];
			int read;

			if (Request.HttpMethod != "POST") {
				Log ("MoonLogProvider: Invalid method. Expected 'POST'.");
				return;
			}
			
			filename = Request ["filename"];
			directory = Environment.GetEnvironmentVariable ("MOONLIGHT_UNIT_HARNESS_LOG_DIRECTORY");
			
			if (string.IsNullOrEmpty (directory) && Environment.OSVersion.Platform == PlatformID.Win32NT)
				directory = @"C:\";

			if (string.IsNullOrEmpty (directory)) {
				directory = Environment.CurrentDirectory;
				Log ("MoonLogProvider: No log directory was set with MOONLIGHT_UNIT_HARNESS_LOG_DIRECTORY, writing to current directory '{0}'.", directory);
			}

			if (string.IsNullOrEmpty (filename)) {
				Log ("MoonLogProvider: No log file was provided.");
				return;
			}

			if (filename.IndexOfAny (Path.GetInvalidFileNameChars ()) != -1) {
				Log ("MoonLogProvider: The filename '{0}' contains invalid characters.", filename);
				return;
			}

			path = Path.Combine (directory, filename);
			
			Log ("MoonLogProvider: Saving file to: {0}", path);
			
			using (BinaryReader reader = new BinaryReader (Request.InputStream)) {
				using (FileStream fs = new FileStream (path, FileMode.Append, FileAccess.Write, FileShare.ReadWrite)) {
					while (true) {
						read = reader.Read (bytes, 0, bytes.Length);
						// Log ("MoonLogProvider: Read {0} bytes.", read);
						// Log ("Read: {0}", System.Text.ASCIIEncoding.ASCII.GetString (bytes, 0, read));
						if (read == 0)
							break;
						fs.Write (bytes, 0, read);
					}
				}
			}
		} catch (Exception ex) {
			Log ("MoonLogProvider: Exception while handling log message: {0}", ex.ToString ());
		}
	}

    public static byte[] GetFileByteData(String fileName)
    {

        FileStream fs = new FileStream(fileName, FileMode.Open);
        BinaryReader br = new BinaryReader(fs);

        byte[] testArray = new byte[fs.Length];
        int count = br.Read(testArray, 0, testArray.Length);

        br.Close();

        return testArray;
    }

 public Crawler Fetch()
 {
     if (!IsExternalIPAddress(this.SourceUrl))
     {
         State = "INVALID_URL";
         return this;
     }
     var request = HttpWebRequest.Create(this.SourceUrl) as HttpWebRequest;
     using (var response = request.GetResponse() as HttpWebResponse)
     {
         if (response.StatusCode != HttpStatusCode.OK)
         {
             State = "Url returns " + response.StatusCode + ", " + response.StatusDescription;
             return this;
         }
         if (response.ContentType.IndexOf("image") == -1)
         {
             State = "Url is not an image";
             return this;
         }
         ServerUrl = PathFormatter.Format(Path.GetFileName(this.SourceUrl), Config.GetString("catcherPathFormat"));
         var savePath = Request.MapPath(ServerUrl);
         if (!Directory.Exists(Path.GetDirectoryName(savePath)))
         {
             Directory.CreateDirectory(Path.GetDirectoryName(savePath));
         }
         try
         {
             var stream = response.GetResponseStream();
             var reader = new BinaryReader(stream);
             byte[] bytes;
             using (var ms = new MemoryStream())
             {
                 byte[] buffer = new byte[4096];
                 int count;
                 while ((count = reader.Read(buffer, 0, buffer.Length)) != 0)
                 {
                     ms.Write(buffer, 0, count);
                 }
                 bytes = ms.ToArray();
             }
             File.WriteAllBytes(savePath, bytes);
             State = "SUCCESS";
         }
         catch (Exception e)
         {
             State = "抓取错误：" + e.Message;
         }
         return this;
     }
 }

    public bool saveFile(HttpContext context, string targetFile)
    {
        var request = context.Request;
        byte[] buffer = new byte[request.ContentLength];
        using (BinaryReader br = new BinaryReader(request.InputStream))
            br.Read(buffer, 0, buffer.Length);

        FileStream fs = new FileStream(targetFile, FileMode.Create,
            FileAccess.ReadWrite);
        BinaryWriter bw = new BinaryWriter(fs);
        bw.Write(buffer);
        bw.Close();
        return true;
    }

    public static GOBFile Open(string path)
    {
        //Debug.Log("GOBFile.Open(" + path + ")");
        FileStream fs = null;
        try { fs = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read); } catch {}
        if (fs == null) {
            Debug.LogError("OpenRead(\"" + path + "\") failed.");
            return null;
        }

        BinaryReader br = new BinaryReader(fs);

        try {
            byte[] id = new byte[4];
            if (br.Read(id, 0, 4) != 4) {
                Debug.LogError("Failed to read GOB header in file " + path + ".");
                fs.Close();
                return null;
            }

            if ((id[0] != 71) || (id[1] != 79) || (id[2] != 66) || (id[3] != 0xA)) {
                fs.Close();
                Debug.LogError("\"" + path + "\" is not a GOB file.");
                return null;
            }

            int dirOfs = br.ReadInt32();

            br.BaseStream.Position = (long)dirOfs;

            int numFiles = br.ReadInt32();

            GOBFile gob = new GOBFile();
            byte[] name = new byte[13];
            for (int i = 0; i < numFiles; ++i) {
                File file = File.Read(br, name);
                gob._dir.Add(file.Name, file);
                // Debug.Log (file.Name);
            }

            gob._file = br;
            return gob;
        } catch  {
            using (br) {}
        }

        return null;
    }