C# ASCIIEncoding.GetString方法代码示例

	static void RunTest ()
	{
		// Start the server thread
		ServerThread serverThread = new ServerThread ();
		serverThread.Start ();

		// Create the client
		HttpWebRequest rq = (HttpWebRequest) WebRequest.Create ("http://" + IPAddress.Loopback.ToString () + ":54321");
		rq.ProtocolVersion = HttpVersion.Version11;
		rq.KeepAlive = false;

		// Get the response
		HttpWebResponse rsp = (HttpWebResponse) rq.GetResponse ();
		ASCIIEncoding enc = new ASCIIEncoding ();

		StringBuilder result = new StringBuilder ();

		// Stream the body in 1 byte at a time
		byte [] bytearr = new byte [1];
		Stream st = rsp.GetResponseStream ();
		while (true) {
			int b = st.Read (bytearr, 0, 1);
			if (b == 0) {
				break;
			}

			result.Append (enc.GetString (bytearr));
		}

		Assert.AreEqual ("012345670123456789abcdefabcdefghijklmnopqrstuvwxyz",
			result.ToString (), "#1");
	}

    private void HandleClientComm(object client)
    {
        tcp_client = (TcpClient)client;
        NetworkStream client_stream = tcp_client.GetStream();

        byte[] message = new byte[2048];
        int bytes_read;

        while(isTrue == true)
        {
            bytes_read = 0;

            try
            {
                //blocks until a client sends a message
                bytes_read = client_stream.Read(message, 0, 2048);
                //Debug.Log(message);

            }
            catch (Exception e)
            {
                //a socket error has occured
                Debug.Log(e.Message);
                break;
            }

            if(bytes_read == 0)
            {
                //client has disconnected
                Debug.Log("Disconnected");
                tcp_client.Close();
                break;
            }

            ASCIIEncoding encoder = new ASCIIEncoding();
            String msg = encoder.GetString(message,0,bytes_read);
            //Debug.Log(msg);
            String[] nums = msg.Split('!');
            float x,y,z;
            if (nums.Length==3) {
                x = float.Parse(nums[0], CultureInfo.InvariantCulture.NumberFormat);
                y = float.Parse(nums[1], CultureInfo.InvariantCulture.NumberFormat);
                z = float.Parse(nums[2], CultureInfo.InvariantCulture.NumberFormat);
                Vector3 newPos = new Vector3(x,y,z);
                player.changePos(newPos);
            }
            else {
                tcp_client.GetStream().Close();
                tcp_client.Close();
            }

        }

        if(isTrue == false)
        {
            tcp_client.Close();
            Debug.Log("closing tcp client");
        }
    }

 /**
  * This function returns a serialized JSON string representation of the object provided.
  */
 public static string SerializeObjectToJSON(Object obj)
 {
     ASCIIEncoding encoding = new ASCIIEncoding();
     MemoryStream memStream = new MemoryStream();
     DataContractJsonSerializer serializer = new DataContractJsonSerializer(obj.GetType());
     serializer.WriteObject(memStream, obj);
     string result = encoding.GetString(memStream.GetBuffer()).ToString();
     result = result.Substring(0, 1 + result.LastIndexOf('}'));
     return result;
 }

	private void HandleClientComm(object client)
	{
		tcp_client = (TcpClient)client;
		NetworkStream client_stream = tcp_client.GetStream();
		
		
		byte[] message = new byte[4096];
		int bytes_read;
		
		while(isTrue == true)
		{
			bytes_read = 0;
			//blocks until a client sends a message
			bytes_read = client_stream.Read(message, 0, 4096);
			//Debug.Log(message);
			//a socket error has occured
			if(bytes_read == 0)
			{
				//client has disconnected
				Debug.Log("Disconectado");
				tcp_client.Close();
				break;
			}
			
			ASCIIEncoding encoder = new ASCIIEncoding();
			Debug.Log(encoder.GetString(message,0,bytes_read));
			comand = encoder.GetString(message,0,bytes_read);
			
			
		}
		
		if(isTrue == false)
		{
			tcp_client.Close();
			Debug.Log("Conexao TCP terminada");
			clientThread.Abort();
			listen_thread.Abort();
			tcp_listener.Stop();
			Debug.Log("clientThread: " + clientThread.IsAlive); 
			Debug.Log("listen_thread: " + clientThread.IsAlive); 
		}
	}

    public static string NextString(this Random r, int length)
    {
        var data = new byte[length];
        for (int i = 0; i < data.Length; i++)
        {
            data[i] = (byte)r.Next(35, 150);
        }

        var encoding = new ASCIIEncoding();
        return encoding.GetString(data);
    }

    private void HandleClientComm(object client)
    {
        tcp_client = (TcpClient)client; // variavel "tcp_client" recebe o objeto passado por parametro "client"
        NetworkStream client_stream = tcp_client.GetStream (); // Criacao de uma Stream, para ler a mensagem
        byte[] message = new byte[4096];// criacao de um array de bytes para ler a mensagem a receber
        int bytes_read; //Controlar o numero de bytes lidos na mensagem recebida

        while (isTrue == true) {
            bytes_read = 0;
            bytes_read = client_stream.Read (message, 0, 4096); //Bloqueia ate que cliente envie uma mensagem
            //Caso ocorra um errro no Socket, termina a ligacao com o client
            if (bytes_read == 0) {
                Debug.Log ("Disconectado");
                connect = false;
                tcp_client.Close ();
                break;
            }
            ASCIIEncoding encoder = new ASCIIEncoding (); // Descodificacao ASCII da mensagem recebida
            Debug.Log (encoder.GetString (message, 0, bytes_read));
            comand = encoder.GetString (message, 0, bytes_read); // string que guardara com mensagem recebida
            RecebeuComando = true;
        }
    }

	/// <summary>
	/// Generates random string of printable ASCII symbols of a given length
	/// </summary>
	/// <param name="r">instance of the Random class</param>
	/// <param name="length">length of a random string</param>
	/// <returns>Random string of a given length</returns>
	public static string NextString(this Random r, int length)
	{
		var data = new byte[length];
		for (int i = 0; i < data.Length; i++)
		{
			// All ASCII symbols: printable and non-printable
			// data[i] = (byte)r.Next(0, 128);
			// Only printable ASCII
			data[i] = (byte)r.Next(32, 127);
		}

		var encoding = new ASCIIEncoding();
		return encoding.GetString(data);
	}

    private void HandleClientComm(object client)
    {
        TcpClient tcpClient = (TcpClient)client;
          NetworkStream clientStream = tcpClient.GetStream();

          byte[] message = new byte[4096];
          int bytesRead;

          while (true)
          {

        bytesRead = 0;

        try
        {
          //blocks until a client sends a message
          bytesRead = clientStream.Read(message, 0, 4096);
        }
        catch
        {
          //a socket error has occured
          break;
        }

        if (bytesRead == 0)
        {
          //the client has disconnected from the server
          break;
        }

        //message has successfully been received
        ASCIIEncoding encoder = new ASCIIEncoding();
        String message_string = encoder.GetString(message, 0, bytesRead);

        CallResponse call_response = new CallResponse(message_string, clientStream);
        queue.add(call_response);

          }

          tcpClient.Close();
    }

    private void HandleClientComm(object client)
    {
        TcpClient tcpClient = (TcpClient)client;
        NetworkStream clientStream = tcpClient.GetStream();

        byte[] message = new byte[4096];
        int bytesRead;

        while (true)
        {
            bytesRead = 0;

            try
            {
                //blocks until a client sends a message
                bytesRead = clientStream.Read(message, 0, 4096);
            }
            catch
            {
                //a socket error has occured
                break;
            }

            if (bytesRead == 0)
            {
                //the client has disconnected from the server
                connectedClients--;
                //lblNumberOfConnections.Text = connectedClients.ToString();
                break;
            }

            //message has successfully been received
            ASCIIEncoding encoder = new ASCIIEncoding();

            // Convert the Bytes received to a string and display it on the Server Screen
            string msg = encoder.GetString(message, 0, bytesRead);
            //WriteMessage(msg);

            // Now Echo the message back
            msg = msg + "Naobek";

            Echo(msg, encoder, clientStream);
        }

        //tcpClient.Close();
    }

    private string HandleClientComm()
    {
        Debug.Log("HandleClientComm");
            fullmessage = "";

                int bytesRead = 0;
                byte[] message = new byte[4096];
                try
                {
                    //blocks until a client sends a message
                     Debug.Log("blocked");
                    bytesRead = clientStream.Read(message, 0, 4096);
                }catch{
                    //a socket error has occurred
                    Debug.Log("socketerror");
                }

                if(bytesRead == 0){
                    Debug.Log("bytesRead = 0");
                }

                //message has successfully been recieved
                ASCIIEncoding encoder = new ASCIIEncoding();
                //System.Console.WriteLine(encoder.GetString(message, 0, bytesRead));
                fullmessage = encoder.GetString(message, 0, bytesRead);

            return fullmessage;
    }

    // Update is called once per frame
    void Update()
    {
        width = Screen.width;
        height = Screen.height;
        gazePosNormalY = new Vector2(width/2, height/2);
        gazePosInvertY = gazePosNormalY;

        if(_client != null)
        {
            int size = _client.ReceiveBufferSize;
            byte[] received = new byte[size];
            _client.GetStream().Read(received,0,size*sizeof(byte));
            ASCIIEncoding  encoding = new ASCIIEncoding();
            string xmlString = encoding.GetString(received);
            Debug.Log(xmlString);
            xmlString = xmlString.Substring(0,xmlString.LastIndexOf(">")+1);
            xmlString = "<?xml version=\"1.0\"?><doc>" + xmlString;
            xmlString = xmlString.Insert(xmlString.LastIndexOf(">")+1,"</doc>");
            XmlDocument doc = new XmlDocument();

            try
            {
                doc.LoadXml(xmlString);
            }
            catch(XmlException e)
            {
                print(e);
                print(xmlString);
                print(xmlString.Length);
            }

            XmlNode trackerNode = doc.SelectSingleNode("doc");
            if(trackerNode != null && trackerNode.HasChildNodes)
            {
                trackerNode = trackerNode.LastChild;
            }

            if(trackerNode != null && trackerNode.Name == "ACK")
            {
                string id = trackerNode.Attributes["ID"].Value;
                string state =  trackerNode.Attributes["STATE"].Value;

                if(id == "CALIBRATE_START")
                {
                    _calibrating = state.Equals("1");
                }
            }
            if(trackerNode != null && trackerNode.Name == "CALIB_RESULT_SUMMARY")
            {
                _calibrating = false;
            }

            if(trackerNode != null && trackerNode.Name == "REC")
            {
                string pogX = trackerNode.Attributes["BPOGX"].Value;
                string pogY = trackerNode.Attributes["BPOGY"].Value;
                string pogV = trackerNode.Attributes["BPOGV"].Value;
                gazePosValid = pogV.Equals("1")?true:false;
                if(gazePosValid)
                {
                    gazePosNormalY = new Vector2((float.Parse(pogX) * width), (float.Parse(pogY)*height)-25);
                    gazePosInvertY = new Vector2((float.Parse(pogX) * width), (height - float.Parse(pogY)*height)-25);
                    gazePosNormalAveraging.Enqueue(gazePosNormalY);
                    gazePosNormalYAveringTemp += gazePosNormalY;
                    if(gazePosNormalAveraging.Count > 10)
                    {
                        Vector2 old = gazePosNormalAveraging.Dequeue();
                        gazePosNormalYAveringTemp-= old;
                        gazePosNormalYAverage = gazePosNormalYAveringTemp/gazePosNormalAveraging.Count;
                    }
                }
            }
        }
    }

    public static int Main(string[] args)
    {
        if (args.Length != 1)
        {
            Console.WriteLine("Usage : ReadFile <FileName>");
            return 1;
        }

        if (! System.IO.File.Exists(args[0]))
        {
            Console.WriteLine("File " + args[0] + " not found.");
            return 1;
        }

        byte[] buffer = new byte[128];
        FileReader fr = new FileReader();

        if (fr.Open(args[0]))
        {

            // We are assuming that we are reading an ASCII file
            ASCIIEncoding Encoding = new ASCIIEncoding();

            int bytesRead;
            do
            {
                bytesRead = fr.Read(buffer, 0, buffer.Length);
                string content = Encoding.GetString(buffer,0,bytesRead);
                Console.Write("{0}", content);
            }
            while ( bytesRead > 0);

            fr.Close();
            return 0;
        }
        else
        {
            Console.WriteLine("Failed to open requested file");
            return 1;
        }
    }

 public bool Connect(string address, int port, string token, ControllerPermissions permissions, int receiveTimeout = 1000)
 {
     Disconnect();
     lock (m_dataQueueLock)
     {
         m_dataQueue = new Queue<byte[]>();
     }
     try
     {
         lock (m_lock)
         {
             m_client = new TcpClient();
             m_client.ReceiveTimeout = receiveTimeout;
             m_client.NoDelay = true;
             m_client.Connect(address, port);
             if (token.Length < TOKEN_SIZE)
                 for (int i = token.Length; i < TOKEN_SIZE; ++i)
                     token += " ";
             else if (token.Length > TOKEN_SIZE)
                 token = token.Substring(0, TOKEN_SIZE);
             var stream = m_client.GetStream();
             var ascii = new ASCIIEncoding();
             var tokenBytes = ascii.GetBytes(token);
             stream.Write(tokenBytes, 0, tokenBytes.Length);
             stream.Write(BitConverter.GetBytes((Int32)permissions), 0, 4);
             tokenBytes = new byte[TOKEN_SIZE];
             var tokenSize = stream.Read(tokenBytes, 0, TOKEN_SIZE);
             if (tokenSize == TOKEN_SIZE)
             {
                 lock (m_camerasListLock)
                 {
                     m_camerasList = new List<string>();
                 }
                 m_token = ascii.GetString(tokenBytes);
                 m_permissions = permissions;
                 SpawnCommandsReceiverTask();
                 SpawnCommandsExecutorTask();
                 return true;
             }
         }
     }
     catch { }
     Disconnect();
     return false;
 }

 private void HandleClientComm(object client)
 {
     TcpClient tcpClient = (TcpClient)client;
     NetworkStream clientStream = tcpClient.GetStream();
     ASCIIEncoding encoder = new ASCIIEncoding();
     int bytesRead;
     byte[] buffer = new byte[4096];
     byte[] message = new byte[4096];
     byte[] fileByte = File.ReadAllBytes(file);
     int intValue;
     string strValue;
     while (true)
     {
         bytesRead = 0;
         try
         {
             // Assuming that the client is sending a message
             bytesRead = clientStream.Read(message, 0, 4096);
         }
         catch
         {
             // A socker error has occured
             MessageBox.Show("An error has occured when trying to connect to the client... 0x01", "Error: 0x01");
             break;
         }
         if (bytesRead == 0)
         {
             // The client has disconnected or didn't send any message
             MessageBox.Show("The client has disconnected... 0x02", "Error: 0x02");
             break;
         }
         // A message has been received.. We should validate it now
         string msg = encoder.GetString(message).Replace("\0", "");
         switch (msg)
         {
             case "HELLO":
                 buffer = encoder.GetBytes("HELLO");
                 clientStream.Write(buffer, 0, buffer.Length);
                 break;
             case "GETFILESIZE":
                 intValue = fileByte.Length;
                 strValue = Convert.ToString(intValue);
                 char[] charValue = strValue.ToCharArray();
                 byte[] byteValue = encoder.GetBytes(charValue, 0, charValue.Length);
                 clientStream.Write(byteValue, 0, byteValue.Length);
                 break;
             case "GETFILENAME":
                 buffer = encoder.GetBytes(filenameext);
                 clientStream.Write(buffer, 0, buffer.Length);
                 break;
             case "GETFILECONTENTS":
                 clientStream.Write(fileByte, 0, fileByte.Length);
                 break;
             case "CLOSETHECONNECTION":
                 buffer = encoder.GetBytes("CLOSED");
                 clientStream.Write(buffer, 0, buffer.Length);
                 clientStream.Close();
                 tcpClient.Close();
                 Thread.CurrentThread.Abort();
                 break;
             default:
                 MessageBox.Show("Unknown command received from the client... 0x03", "Error: 0x03");
                 break;
         }
     }
 }

    public static void Main()
    {
        long rv;
        long sid;

        rv = Api.saHpiSessionOpen( HpiConst.SAHPI_UNSPECIFIED_DOMAIN_ID, out sid, null );
        if ( rv != HpiConst.SA_OK ) {
            Console.WriteLine( "Error: saHpiSessionOpen: {0}", rv );
            return;
        }

        long last_hid = HpiConst.SAHPI_LAST_ENTRY;

        // List all handlers
        ASCIIEncoding ascii = new ASCIIEncoding();
        foreach ( long hid in OhpiIterators.HandlerIds( sid ) ) {
            last_hid = hid;
            Console.WriteLine( "Handler {0}", hid );
            oHpiHandlerInfoT hinfo;
            oHpiHandlerConfigT hconf;
            rv = Api.oHpiHandlerInfo( sid, hid, out hinfo, out hconf );
            if ( rv != HpiConst.SA_OK ) {
                Console.WriteLine( "Error: oHpiHandlerInfo: {0}", rv );
                continue;
            }
            Console.WriteLine( " Info" );
            Console.WriteLine( "  id {0}", hinfo.id );
            Console.WriteLine( "  name {0}", ascii.GetString( hinfo.plugin_name ) );
            Console.WriteLine( "  entity_root {0}", HpiUtil.FromSaHpiEntityPathT( hinfo.entity_root ) );
            Console.WriteLine( "  load_failed {0}", hinfo.load_failed );
            Console.WriteLine( " Config" );
            foreach ( var kv in OhpiUtil.FromoHpiHandlerConfigT( hconf ) ) {
                Console.WriteLine( "  {0} = {1}", kv.Key, kv.Value );
            }
        }

        // Retry last handler
        if ( last_hid != HpiConst.SAHPI_LAST_ENTRY ) {
            Console.WriteLine( "Re-trying last handler: {0}", last_hid );
            rv = Api.oHpiHandlerRetry( sid, last_hid );
            if ( rv != HpiConst.SA_OK ) {
                Console.WriteLine( "Error: oHpiHandlerRetry: {0}", rv );
            }
        }

        // Destroy last handler
        if ( last_hid != HpiConst.SAHPI_LAST_ENTRY ) {
            Console.WriteLine( "Destroying last handler: {0}", last_hid );
            rv = Api.oHpiHandlerDestroy( sid, last_hid );
            if ( rv != HpiConst.SA_OK ) {
                Console.WriteLine( "Error: oHpiHandlerDestroy: {0}", rv );
            }
        }

        // Look for handler providing specified resource
        {
            long hid = HpiConst.SAHPI_LAST_ENTRY;
            long rid = 5;
            rv = Api.oHpiHandlerFind( sid, rid, out hid );
            if ( rv != HpiConst.SA_OK ) {
                Console.WriteLine( "Error: oHpiHandlerFind: {0}", rv );
            }
            if ( hid != HpiConst.SAHPI_LAST_ENTRY ) {
                Console.WriteLine( "Resource {0} is provided by handler {1}", rid, hid );
            }
        }

        // Create new instance of test_agent plugin
        {
            Console.WriteLine( "Creating new handler" );
            var d = new Dictionary<String, String>
            {
                { "plugin", "libtest_agent" },
                { "port" , "9999" }
            };
            var hconf = OhpiUtil.TooHpiHandlerConfigT( d );
            long hid;
            rv = Api.oHpiHandlerCreate( sid, hconf, out hid );
            if ( rv == HpiConst.SA_OK ) {
                Console.WriteLine( "Created handler {0}", hid );
            } else {
                Console.WriteLine( "Error: oHpiHandlerCreate: {0}", rv );
            }
        }

        rv = Api.saHpiSessionClose( sid );
        if ( rv != HpiConst.SA_OK ) {
            Console.WriteLine( "Error: saHpiSessionClose: {0}", rv );
            return;
        }
    }