C# StringReader类代码示例

        /// <summary>
        /// Parses "Min-SE" from specified reader.
        /// </summary>
        /// <param name="reader">Reader from where to parse.</param>
        /// <exception cref="ArgumentNullException">Raised when <b>reader</b> is null.</exception>
        /// <exception cref="SIP_ParseException">Raised when invalid SIP message.</exception>
        public override void Parse(StringReader reader)
        {
            /*
                Min-SE = delta-seconds *(SEMI generic-param)
            */

            if(reader == null){
                throw new ArgumentNullException("reader");
            }

            // Parse address
            string word = reader.ReadWord();
            if(word == null){
                throw new SIP_ParseException("Min-SE delta-seconds value is missing !");
            }
            try{
                m_Time = Convert.ToInt32(word);
            }
            catch{
                throw new SIP_ParseException("Invalid Min-SE delta-seconds value !");
            }

            // Parse parameters
            ParseParameters(reader);
        }

 //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
 //ORIGINAL LINE: public void testStemming() throws Exception
 public virtual void testStemming()
 {
     Reader reader = new StringReader("cariñosa");
     TokenStream stream = new MockTokenizer(reader, MockTokenizer.WHITESPACE, false);
     stream = tokenFilterFactory("GalicianStem").create(stream);
     assertTokenStreamContents(stream, new string[] {"cariñ"});
 }

        public static void Serialization1(Human human)
        {
            XmlSerializer serializer = new XmlSerializer(typeof(Human));
            StringBuilder sb = new StringBuilder();

            /* SERIALIZATION */
            using (StringWriter writer = new StringWriter(sb))
            {
                serializer.Serialize(writer, human);
            }
            // XML file
            //Console.WriteLine("SB: " +sb.ToString());
            /* END SERIALIZATION */



            /* DESERIALIZATION */
            Human newMartin = new Human();
            using (StringReader reader = new StringReader(sb.ToString()))
            {
                newMartin = serializer.Deserialize(reader) as Human;
            }
            Console.WriteLine(newMartin.ToString() + Environment.NewLine);
            /* END DESERIALIZATION */
        }

    void NameEntered()
    {
        congratulationsUILabel.text = "";
        PlayerPrefs.SetString("name", playerName);

        StringReader reader = new StringReader(PlayerPrefs.GetString(Application.loadedLevel+"","600 IACONIC\n1200 IACONIC\n1800 IACONIC\n2400 IACONIC\n3000 IACONIC\n3600 IACONIC\n4200 IACONIC\n4800 IACONIC\n5400 IACONIC\n6000 IACONIC"));
        string output = "";
        bool counted = false;
        timeUILabel.text = "";
        nameUILabel.text = "";
        for(int i = 0; i < 10; i ++)
        {
            string input = reader.ReadLine();
            int timer = int.Parse(input.Split(' ')[0]);
            if(playTime<timer&&!counted)
            {
                timeUILabel.text += TimeToString(playTime) + "\n";
                nameUILabel.text += playerName + "\n";
                output += playTime + " " + playerName + "\n";
                i ++;
                counted = true;
            }
            timeUILabel.text += TimeToString(timer);
            nameUILabel.text += input.Split(' ')[1];
            if(i!=9)
            {
                timeUILabel.text +=  "\n";
                nameUILabel.text +=  "\n";
            }
            output += input + "\n";
        }
        reader.Close();
        PlayerPrefs.SetString(Application.loadedLevel+"",output);
    }

        /// <summary>
        /// Parses "CSeq" from specified reader.
        /// </summary>
        /// <param name="reader">Reader from where to parse.</param>
        /// <exception cref="ArgumentNullException">Raised when <b>reader</b> is null.</exception>
        /// <exception cref="SIP_ParseException">Raised when invalid SIP message.</exception>
        public override void Parse(StringReader reader)
        {
            // CSeq = 1*DIGIT LWS Method

            if(reader == null){
                throw new ArgumentNullException("reader");
            }

            // Get sequence number
            string word = reader.ReadWord();
            if(word == null){
                throw new SIP_ParseException("Invalid 'CSeq' value, sequence number is missing !");
            }
            try{
                m_SequenceNumber = Convert.ToInt32(word);
            }
            catch{
                throw new SIP_ParseException("Invalid CSeq 'sequence number' value !");
            }

            // Get request method
            word = reader.ReadWord();
            if(word == null){
                throw new SIP_ParseException("Invalid 'CSeq' value, request method is missing !");
            }
            m_RequestMethod = word;
        }

 //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
 //ORIGINAL LINE: public void testTrimming() throws Exception
 public virtual void testTrimming()
 {
     Reader reader = new StringReader("trim me    ");
     TokenStream stream = new MockTokenizer(reader, MockTokenizer.KEYWORD, false);
     stream = tokenFilterFactory("Trim").create(stream);
     assertTokenStreamContents(stream, new string[] {"trim me"});
 }

    protected List<Dictionary<string, int>> loadLevel(int level)
    {
        if(reader == null){
            text = (TextAsset)Resources.Load("LevelDesign/fases/fase" + level,typeof(TextAsset));
            reader = new StringReader(text.text);
        }

        while((line = reader.ReadLine()) != null){
            if(line.Contains(",")){
                string[] note = line.Split(new char[]{','});
                phaseNotes.Add(new Dictionary<string,int>(){
                    {"time",int.Parse(note[0])},
                    {"show",int.Parse(note[1])},
                    {"note",int.Parse(note[2])}
                });
                linecount++;
            }else if(line.Contains("tick"))
            {
                string[] tick = line.Split(new char[]{':'});
                musicTick = float.Parse(tick[tick.Length - 1]);

                linecount ++;
            }
        }
        linecount = 0;

        return getNotesDuration(excludeDoubleNotes(phaseNotes));
    }

    static void Main()
    {
        Dictionary<string, string> dictionary = new Dictionary<string, string>();

        string textLines = @".NET - platform for applications from Microsoft
        CLR - managed execution environment for .NET
        namespace - hierarchical organization of classes
        ";

        StringReader readLines = new StringReader(textLines);

        string line;
        while ((line = readLines.ReadLine())!=null)
        {
            string[] token = line.Split('-');
            dictionary.Add(token[0].Trim(), token[1]);
        }

        string input = Console.ReadLine();

        if (dictionary.ContainsKey(input))
        {
            Console.WriteLine(dictionary[input]);
        }
        else
        {
            Console.WriteLine("No such term in dictionary");
        }
    }

    public static LevelData Load(TextAsset asset)
    {
        LevelData level = null;
        var serializer = new XmlSerializer(typeof(LevelData));

        using (var stream = new StringReader(asset.text))
        {
            level = serializer.Deserialize(stream) as LevelData;
        }

        int yLength = level.Rows.Length;
        int xLength = yLength > 0 ? level.Rows[0].RowLength : 0;

        level.Grid = new int[xLength, yLength];

        for (int y = 0; y < yLength; ++y)
        {
            char[] row = level.Rows[y].RowData.ToCharArray();

            for (int x = 0; x < xLength; ++x)
            {
                level.Grid[x, y] = row[x] == WALL ? 1 : 0;
            }
        }

        return level;
    }

    //Funcion que con el nombre del nivel (el mismo que el del xml) crea los gameobjects del nivel
    public GameObject generateLevel(string nameLevel)
    {
        //Extraemos el XML y lo deserializamos
        TextAsset xmlTextAsset = (TextAsset)Resources.Load("LevelsXML/"+nameLevel, typeof(TextAsset));
        StringReader stream = new StringReader(xmlTextAsset.text);
        XmlSerializer s = new XmlSerializer(typeof(structureXML));
        m_structureXML = s.Deserialize(stream) as structureXML;

        //Creamos un gameObject vacio que representará el nivel
        GameObject goLevel = new GameObject(nameLevel);
        goLevel.transform.position = Vector3.zero;
        goLevel.transform.parent = Managers.GetInstance.SceneMgr.rootScene.transform;

        Managers.GetInstance.TimeMgr.seconds = m_structureXML.time.seconds;
        Managers.GetInstance.SceneMgr.spawnPointPlayer = new Vector3(m_structureXML.spawnPoint.x, m_structureXML.spawnPoint.y, 0);

        //Creamos cada uno de los items definidos en el XML en la posicion alli indicada, con el scale alli indicado.
        foreach (structureXML.Item go in m_structureXML.prefabs.items)
        {
            GameObject newGO = Managers.GetInstance.SpawnerMgr.createGameObject(Resources.Load("Prefabs/GamePrefabs/" + go.prefab) as GameObject, new Vector3(go.x, go.y, 0), Quaternion.identity);
            newGO.transform.localScale = new Vector3(go.scaleX, go.scaleY, 1);
            //Finalmente como padre ponemos al gameObject que representa el nivel
            newGO.transform.parent = goLevel.transform;
        }

        return goLevel;
    }

 object Deserialize(string messageBody, Type objectType)
 {
     using (StringReader textReader = new StringReader(messageBody))
     {
         return serializer.Deserialize(textReader, objectType);
     }
 }

        /// <summary>
        /// Parses LSUB response from lsub-response string.
        /// </summary>
        /// <param name="lSubResponse">LSub response string.</param>
        /// <returns>Returns parsed lsub response.</returns>
        /// <exception cref="ArgumentNullException">Is raised when <b>lSubResponse</b> is null reference.</exception>
        public static IMAP_r_u_LSub Parse(string lSubResponse)
        {
            if(lSubResponse == null){
                throw new ArgumentNullException("lSubResponse");
            }

            /* RFC 3501 7.2.3. LSUB Response.
                Contents:   name attributes
                            hierarchy delimiter
                            name

                The LSUB response occurs as a result of an LSUB command.  It
                returns a single name that matches the LSUB specification.  There
                can be multiple LSUB responses for a single LSUB command.  The
                data is identical in format to the LIST response.

                Example:    S: * LSUB () "." #news.comp.mail.misc
            */

            StringReader r = new StringReader(lSubResponse);
            // Eat "*"
            r.ReadWord();
            // Eat "LSUB"
            r.ReadWord();

            string attributes = r.ReadParenthesized();
            string delimiter  = r.ReadWord();
            string folder     = TextUtils.UnQuoteString(IMAP_Utils.DecodeMailbox(r.ReadToEnd().Trim()));

            return new IMAP_r_u_LSub(folder,delimiter[0],attributes == string.Empty ? new string[0] : attributes.Split(' '));
        }

        /// <summary>
        /// Parses media from "t" SDP message field.
        /// </summary>
        /// <param name="tValue">"t" SDP message field.</param>
        /// <returns></returns>
        public static SDP_Time Parse(string tValue)
        {
            // t=<start-time> <stop-time>

            SDP_Time time = new SDP_Time();

            // Remove t=
            StringReader r = new StringReader(tValue);
            r.QuotedReadToDelimiter('=');

            //--- <start-time> ------------------------------------------------------------
            string word = r.ReadWord();
            if(word == null){
                throw new Exception("SDP message \"t\" field <start-time> value is missing !");
            }
            time.m_StartTime = Convert.ToInt64(word);

            //--- <stop-time> -------------------------------------------------------------
            word = r.ReadWord();
            if(word == null){
                throw new Exception("SDP message \"t\" field <stop-time> value is missing !");
            }
            time.m_StopTime = Convert.ToInt64(word);

            return time;
        }

 //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
 //ORIGINAL LINE: public void testStemming() throws Exception
 public virtual void testStemming()
 {
     Reader reader = new StringReader("abc");
     TokenStream stream = new MockTokenizer(reader, MockTokenizer.WHITESPACE, false);
     stream = tokenFilterFactory("HunspellStem", "dictionary", "simple.dic", "affix", "simple.aff").create(stream);
     assertTokenStreamContents(stream, new string[] {"ab"});
 }

    // Use this for initialization
    void Start()
    {
        //DELETE THIS BEFORE RELEASE

        Data temp = GameObject.FindGameObjectWithTag("Load").GetComponent<Data>();
        Debug.Log("1");
        if (!temp.loaded)
        {
            Debug.Log("2");
            string s = PlayerPrefs.GetString(ADDRESS, "FIRST!");
            Debug.Log(s);
            if (!s.Equals("FIRST!"))
            {

                StringReader status = new StringReader(s);
                stats = (SavedData)serialize.Deserialize(status);
                Debug.Log(stats.gold);
            }
            else
            {
                stats = new SavedData();
                Debug.Log("no");
            }
            temp.setStats(stats);
        }
    }