C# StringReader.Read方法代码示例

    int ReadNextNumber(StringReader input)
    {
        string result = "";
        while (input.Peek() >= 0) {
            char c = (char)input.Read();
            if (c == '\r') {
                input.Read();
                break;
            } else if (c == '\n' || c == ' ' || c == '\t') {
                break;
            }

            result += c;
        }

        if (result == "") {
            return -9999;
        } else {
            return int.Parse(result);
        }
    }

        public void ReadReadsExactlyNCharacters(string input, string expected1, string expected2)
        {
            // Arrange
            var stringReader = new StringReader(input);

            // Act
            string actual1 = stringReader.Read(n: 5);
            string actual2 = stringReader.Read(n: 5);

            // Assert
            Assert.Equal(expected1, actual1);
            Assert.Equal(expected2, actual2);
        }

        public void ReadReadsCharacter(string input, char expected1, char expected2)
        {
            // Arrange
            var stringReader = new StringReader(input);

            // Act
            char actual1 = stringReader.Read();
            char actual2 = stringReader.Read();

            // Assert
            Assert.Equal(expected1, actual1);
            Assert.Equal(expected2, actual2);
        }

    void Start()
    {
        cameraController = Camera.main.GetComponent<CameraController>();

        try {
            using (StreamReader sr = new StreamReader(Application.dataPath + "/Levels/" + "01.txt")) {
                string line;
                int gridY = gridHeight-1;

                while ((line = sr.ReadLine()) != null) {
                    // if line.Lenght != gridWidth-1 and other conditions
                    char[] chars = new char[gridWidth];
                    using (StringReader sgr = new StringReader(line)) {
                        sgr.Read(chars, 0, gridWidth);
                        int gridX = 0;
                        foreach (char c in chars) {
                            CreateInstance(c, gridX, gridY);
                            gridX++;
                        }
                    }
                    gridY--;
                }
            }
        } catch (Exception e) {
            Debug.LogException(e);
        }
    }

	public bool runTest()
	{
		Console.WriteLine(s_strTFPath + "\\" + s_strTFName + " , for " + s_strClassMethod + " , Source ver " + s_strDtTmVer);
		int iCountErrors = 0;
		int iCountTestcases = 0;
		String strValue = String.Empty;
		Char[] chArr = new Char[]{
			Char.MinValue
			,Char.MaxValue
			,'\t'
			,' '
			,'$'
			,'@'
			,'#'
			,'\0'
			,'\v'
			,'\''
			,'\u3190'
			,'\uC3A0'
			,'A'
			,'5'
			,'\uFE70' 
			,'-'
			,';'
			,'\u00E6'
			,'\n'
			,'\v'
		};
		try {
			StringBuilder sb = new StringBuilder(40);
			StringWriter sw = new StringWriter(sb);
			StringReader sr;
			for(int i = 0 ; i < chArr.Length ; i++)
				sb.Append(chArr[i]);
			sw.Write(sb.ToString());
			sr = new StringReader(sw.GetStringBuilder().ToString());
			Int32 tmp = 0;
			for(int i = 0 ; i < chArr.Length ; i++) {
				iCountTestcases++;
				if((tmp = sr.Read()) != (Int32)chArr[i]) {
					iCountErrors++;
					printerr( "Error_298vc_"+i+"! Expected=="+(Int32)chArr[i]+", got=="+tmp);
				}
			}
		} catch (Exception exc) {
			iCountErrors++;
			printerr( "Error_298yg! Unexpected exception thrown, exc=="+exc.ToString());
		}
		if ( iCountErrors == 0 )
		{
			Console.WriteLine( "paSs. "+s_strTFName+" ,iCountTestcases=="+iCountTestcases.ToString());
			return true;
		}
		else
		{
			Console.WriteLine("FAiL! "+s_strTFName+" ,iCountErrors=="+iCountErrors.ToString()+" , BugNums?: "+s_strActiveBugNums );
			return false;
		}
	}

    public String YourMethod(String texto, String numero)
    {
        try
        {
            int n = int.Parse(numero);
            char ch = 'p';
            String s = "<p>";
            StringReader reader;
            reader = new StringReader(texto);
            while (reader.Peek() > -1)
            {
                for (int i = 0; i < n; ++i)
                {
                        if (i == n - 1)
                        {
                            if ((char)reader.Peek() != ' ')
                            {
                                ch = (char)reader.Read();
                                s += ch;
                            }
                        }
                        else {
                            ch = (char)reader.Read();
                            s += ch;
                        }
                    }
                    if (reader.Peek() > -1 && (char)reader.Peek() != ' ')
                {
                    s += "-";
                }
                else
                {
                    reader.Read();
                }
                s += "\n</p><p>";
            }
            return s;
        }
        catch (FormatException)
        {

        }
        return "error";

    }

	public bool runTest()
	{
		int iCountErrors = 0;
		int iCountTestcases = 0;
        String strTemp = String.Empty ;
        Char[] cArr = new Char[10] ;
        StringBuilder sb = new StringBuilder(40);
        StringWriter sw = new StringWriter(sb);
        StringReader sr;
        iCountTestcases++;
        bool[] bArr = new bool[]{  true,true,true,true,true,false,false,false,false,false};
		try {
			for(int i = 0 ; i < bArr.Length ; i++)
				sw.WriteLine(bArr[i]);
			sr = new StringReader(sw.GetStringBuilder().ToString());
			for(int i = 0 ; i < bArr.Length ; i++) {
                sr.Read(cArr, 0, bArr[i].ToString().Length+System.Environment.NewLine.Length);
				if(new String(cArr, 0, bArr[i].ToString().Length) != bArr[i].ToString()) {
					iCountErrors++;
					printerr( "Error_298vc_"+i+"! Expected=="+bArr[i].ToString()+", got=="+new String(cArr));
				}
			}
		} catch (Exception exc) {
			iCountErrors++;
			printerr( "Error_298yg! Unexpected exception thrown, exc=="+exc.ToString());
		}
        iCountTestcases++;
        bArr = new bool[10000];
        for(int i = 0 ; i < bArr.Length ; i++)
            bArr[i] = Convert.ToBoolean(rand.Next(0,2));
		try {
            sb.Length = 0;
			for(int i = 0 ; i < bArr.Length ; i++)
				sw.WriteLine(bArr[i]);
			sr = new StringReader(sw.GetStringBuilder().ToString());
			for(int i = 0 ; i < bArr.Length ; i++) {
                sr.Read(cArr, 0, bArr[i].ToString().Length+System.Environment.NewLine.Length);
                if(new String(cArr, 0, bArr[i].ToString().Length) != bArr[i].ToString()) {
					iCountErrors++;
					printerr( "Error_57485_"+i+"! Expected=="+bArr[i].ToString()+", got=="+new String(cArr));
				}
			}
		} catch (Exception exc) {
			iCountErrors++;
			printerr( "Error_43432! Unexpected exception thrown, exc=="+exc.ToString());
		}
        if ( iCountErrors == 0 )
		{
			Console.WriteLine( "paSs. iCountTestcases=="+iCountTestcases.ToString());
			return true;
		}
		else
		{
			Console.WriteLine("FAiL! iCountErrors=="+iCountErrors.ToString() );
			return false;
		}
	}

	public bool runTest()
	{
		Console.WriteLine(s_strTFPath + "\\" + s_strTFName + " , for " + s_strClassMethod + " , Source ver " + s_strDtTmVer);
		int iCountErrors = 0;
		int iCountTestcases = 0;
		String strLoc = "Loc_000oo";
		String strValue = String.Empty;
		try
		{
			StringReader sr;
			strLoc = "Loc_98yg7";
			iCountTestcases++;
			try {		
                sr = new StringReader(null);
                String strTemp = sr.ReadToEnd();
				iCountErrors++;
				printerr( "Error_18syx! StringReader should only hold null");
				sr.ReadLine();
				sr.Peek();
				sr.Read();
				sr.Close();
			} catch (ArgumentNullException exc) {
				printinfo("Expected exception thrown, exc=="+exc.Message);
			}catch (Exception exc) {
				iCountErrors++;
				printerr("Error_109xu! Unexpected exception thrown, exc=="+exc.ToString());
			}
			strLoc = "Loc_4790s";
			sr = new StringReader(String.Empty);
			iCountTestcases++;
			if(!sr.ReadToEnd().Equals(String.Empty)) {
				iCountErrors++;
				printerr( "Error_099xa! Incorrect construction");
			}		   		 
			strLoc = "Loc_8388x";
			sr = new StringReader("Hello\0World");
			iCountTestcases++;
			if(!sr.ReadToEnd().Equals("Hello\0World")) {
				iCountErrors++;
				printerr( "Error_1099f! Incorrect construction");
			}
		} catch (Exception exc_general ) {			
			++iCountErrors;
			Console.WriteLine (s_strTFAbbrev + " : Error Err_8888yyy!  strLoc=="+ strLoc +", exc_general=="+exc_general.ToString());
		}
		if ( iCountErrors == 0 )
		{
			Console.WriteLine( "paSs. "+s_strTFName+" ,iCountTestcases=="+iCountTestcases.ToString());
			return true;
		}
		else
		{
			Console.WriteLine("FAiL! "+s_strTFName+" ,iCountErrors=="+iCountErrors.ToString()+" , BugNums?: "+s_strActiveBugNums );
			return false;
		}
	}

    // ---------------------------------------------------------------------
    //
    // Constructors
    //
    // ---------------------------------------------------------------------

    #region Constructors

    /// <summary>
    /// initializes the _inputStringReader member with the string to be read
    /// also sets initial values for _nextCharacterCode and _nextTokenType
    /// </summary>
    /// <param name="inputTextString">
    /// text string to be parsed for xml content
    /// </param>
    internal HtmlLexicalAnalyzer(string inputTextString)
    {
        _inputStringReader = new StringReader(inputTextString);
        _nextCharacterCode = 0;
        _nextCharacter = ' ';
        _lookAheadCharacterCode = _inputStringReader.Read();
        _lookAheadCharacter = (char)_lookAheadCharacterCode;
        _previousCharacter = ' ';
        _ignoreNextWhitespace = true;
        _nextToken = new StringBuilder(100);
        _nextTokenType = HtmlTokenType.Text;
        // read the first character so we have some value for the NextCharacter property
        this.GetNextCharacter();
    }

        public ConfigFilesFilter(RandoopConfiguration config)
        {
            if (config == null) throw new ArgumentNullException("config");

            Common.StringReader r = new StringReader();

            foreach (FileName path in config.forbid_typesFiles)
                forbid_types.AddRange(r.Read(path.fileName));

            foreach (FileName path in config.forbid_membersFiles)
                forbid_members.AddRange(r.Read(path.fileName));

            foreach (FileName path in config.forbid_fieldsFiles)
                forbid_fields.AddRange(r.Read(path.fileName));

            foreach (FileName path in config.require_typesFiles)
                require_types.AddRange(r.Read(path.fileName));

            foreach (FileName path in config.require_membersFiles)
                require_members.AddRange(r.Read(path.fileName));

            foreach (FileName path in config.require_fieldsFiles)
                require_fields.AddRange(r.Read(path.fileName));
        }

		/// <summary>Swaps e.g. < with &gt; so the text won't get treated like xml/html.</summary>
		/// <param name="xml">The xml to escape.</param>
		/// <returns>The escaped string.</returns>
		public static string Escape(string xml){
			StringReader reader=new StringReader(xml);
			System.Text.StringBuilder result=new System.Text.StringBuilder();
			
			while(reader.More()){
				char character=reader.Read();
				if(character=='<'){
					result.Append("&lt;");
				}else if(character=='>'){
					result.Append("&gt;");
				}else if(character=='&'){
					result.Append("&amp;");
				}else{
					result.Append(character);
				}
			}
			return result.ToString();
		}

    // This method checks if every char of the String is a digit
    // This returns the boolean result
    private bool parseConstant(String constant)
    {
        bool exp = false;
        StringReader reader = new StringReader(constant);
        while (reader.Peek() != -1)
        {
            var digit = (char)reader.Read();
            if (isDigit(digit))
            {
                exp = true;
            }
            else
            {
                exp = false;
                break;
            }

        }
        reader.Close();
        return exp;
    }

		/// <summary>
		/// UrlEncodes a string without the requirement for System.Web
		/// </summary>
		/// <param name="String"></param>
		/// <returns></returns>
		public static string UrlEncode(string InputString)
		{
			StringReader sr = new StringReader(InputString);
			StringBuilder sb = new StringBuilder(InputString.Length);

			while (true)
			{
				int Value = sr.Read();
				if (Value == -1)
					break;
				char CharValue = (char)Value;

				if (CharValue >= 'a' && CharValue <= 'z' ||
					CharValue >= 'A' && CharValue <= 'Z' ||
					CharValue >= '0' && CharValue <= '9')
					sb.Append(CharValue);
				else if (CharValue == ' ')
					sb.Append("+");
				else
					sb.AppendFormat("%{0:X2}", Value);
			}

			return sb.ToString();
		}

		/// <summary>
		/// UrlDecodes a string without requiring System.Web
		/// </summary>
		/// <param name="InputString">String to decode.</param>
		/// <returns>decoded string</returns>
		public static string UrlDecode(string InputString)
		{
			char temp = ' ';
			StringReader sr = new StringReader(InputString);
			StringBuilder sb = new StringBuilder(InputString.Length);

			while (true)
			{
				int lnVal = sr.Read();
				if (lnVal == -1)
					break;
				char TChar = (char)lnVal;
				if (TChar == '+')
					sb.Append(' ');
				else if (TChar == '%')
				{
					// *** read the next 2 chars and parse into a char
					temp = (char)Int32.Parse(((char)sr.Read()).ToString() + ((char)sr.Read()).ToString(),
						System.Globalization.NumberStyles.HexNumber);
					sb.Append(temp);
				}
				else
					sb.Append(TChar);
			}

			return sb.ToString();
		}

    static public int sscanf(String stream, String format, Object[] results)
    {
        int fieldsRead = 0;
        int resultsIndex = 0;
        int formatIndex = 0;
        char fieldType = '\0';
        char charRead = '\0';
        bool readingField = false;
        bool eatWhiteSpace = false;
        StringReader srStream = new StringReader(stream);

        while (formatIndex < format.Length)
        {
            if (Char.IsWhiteSpace((char)format[formatIndex]))
            {
                eatWhiteSpace = true;
                formatIndex++;
                continue;
            }
            while (eatWhiteSpace)
            {
                if (!Char.IsWhiteSpace((char)srStream.Peek()))
                {
                    eatWhiteSpace = false;
                    break;
                }
                srStream.Read();
            }
            if ('%' == format[formatIndex])  //If we found a scan field type
            {
                StringBuilder sb = new StringBuilder();
                ++formatIndex;
                fieldType = format[formatIndex++];
                readingField = true;
                charRead = (char)srStream.Read();

                while (readingField)
                {
                    if (-1 == (short)charRead)
                    {
                        readingField = false;
                    }

                    sb.Append(charRead);

                    int intCharRead = srStream.Peek();
                    unchecked
                    {
                        charRead = (char)intCharRead;
                    }
                    if (Char.IsWhiteSpace(charRead) || ('c' == fieldType) || (-1 == intCharRead))
                    {
                        readingField = false;
                        fieldsRead++;

                        switch (fieldType)
                        {
                            case 'c':
                                results[resultsIndex++] = sb.ToString()[0];
                                break;
                            case 'd':
                            case 'i':
                                int parsedInt;
                                parsedInt = int.Parse(sb.ToString());
                                results[resultsIndex++] = parsedInt;
                                break;
                            case 'f':
                                double parsedDouble;
                                parsedDouble = double.Parse(sb.ToString());
                                results[resultsIndex++] = parsedDouble;
                                break;
                            case 's':
                                results[resultsIndex++] = sb.ToString();
                                break;
                        }
                        continue;
                    }
                    charRead = (char)srStream.Read();
                }
            }
        }

        return fieldsRead;
    }