C# ASCIIEncoding.GetString方法代码示例

 //Connect to the client
 public void connect()
 {
     if (!clientConnected)
     {
         IPAddress ipAddress = IPAddress.Any;
         TcpListener listener = new TcpListener(ipAddress, portSend);
         listener.Start();
         Console.WriteLine("Server is running");
         Console.WriteLine("Listening on port " + portSend);
         Console.WriteLine("Waiting for connections...");
         while (!clientConnected)
         {
             s = listener.AcceptSocket();
             s.SendBufferSize = 256000;
             Console.WriteLine("Connection accepted from " + s.RemoteEndPoint);
             byte[] b = new byte[65535];
             int k = s.Receive(b);
             ASCIIEncoding enc = new ASCIIEncoding();
             Console.WriteLine("Received:" + enc.GetString(b, 0, k) + "..");
             //Ensure the client is who we want
             if (enc.GetString(b, 0, k) == "hello" || enc.GetString(b, 0, k) == "hellorcomplete")
             {
                 clientConnected = true;
                 Console.WriteLine(enc.GetString(b, 0, k));
             }
         }
     }
 }

        public object Search(queryrequest xml)
        {
            SemWeb.Query.Query query = null;

            string q = string.Empty;

            try
            {
                query = new SparqlEngine(new StringReader(xml.query));
            }
            catch (QueryFormatException ex)
            {
                var malformed = new malformedquery();

                malformed.faultdetails = ex.Message;

                return malformed;
            }

            // Load the data from sql server
            SemWeb.Stores.SQLStore store;

            string connstr = ConfigurationManager.ConnectionStrings["SemWebDB"].ConnectionString;

            DebugLogging.Log(connstr);

            store = (SemWeb.Stores.SQLStore)SemWeb.Store.CreateForInput(connstr);

            //Create a Sink for the results to be writen once the query is run.
            MemoryStream ms = new MemoryStream();
            XmlTextWriter writer = new XmlTextWriter(ms, System.Text.Encoding.UTF8);
            QueryResultSink sink = new SparqlXmlQuerySink(writer);

            try
            {
                // Run the query.
                query.Run(store, sink);

            }
            catch (Exception ex)
            {
                // Run the query.
                query.Run(store, sink);
                DebugLogging.Log("Run the query a second time");
                DebugLogging.Log(ex.Message);

            }
            //flush the writer then  load the memory stream
            writer.Flush();
            ms.Seek(0, SeekOrigin.Begin);

            //Write the memory stream out to the response.
            ASCIIEncoding ascii = new ASCIIEncoding();
            DebugLogging.Log(ascii.GetString(ms.ToArray()).Replace("???", ""));
            writer.Close();

            DebugLogging.Log("End of Processing");

            return SerializeXML.DeserializeObject(ascii.GetString(ms.ToArray()).Replace("???", ""), typeof(sparql)) as sparql;
        }

 /// <summary>
 /// Wrap a message as a CTCP command
 /// </summary>
 /// <param name="message">
 /// The message.
 /// </param>
 /// <param name="ctcpCommand">
 /// The CTCP command.
 /// </param>
 /// <returns>
 /// The <see cref="string"/>.
 /// </returns>
 public static string SetupForCtcp(this string message, string ctcpCommand)
 {
     var asc = new ASCIIEncoding();
     byte[] ctcp = { Convert.ToByte(1) };
     return asc.GetString(ctcp) + ctcpCommand.ToUpper()
            + (message == string.Empty ? string.Empty : " " + message) + asc.GetString(ctcp);
 }

        public TRK(Stream Data)
        {
            m_Reader = new FileReader(Data, false);
            string DataStr = "";
            string[] Elements;

            ASCIIEncoding Enc = new ASCIIEncoding();
            string MagicNumber = Enc.GetString(m_Reader.ReadBytes(4));

            if (!MagicNumber.Equals("2DKT", StringComparison.InvariantCultureIgnoreCase) && !MagicNumber.Equals("TKDT", StringComparison.InvariantCultureIgnoreCase))
                throw new HitException("Invalid TrackData header - TRK.cs");

            if (MagicNumber.Equals("2DKT", StringComparison.InvariantCultureIgnoreCase))
            {
                DataStr = Enc.GetString(m_Reader.ReadBytes((int)m_Reader.ReadUInt32()));
                Elements = DataStr.Split(',');
            }
            else
                Elements = Enc.GetString(m_Reader.ReadToEnd()).Split(',');

            m_Version = int.Parse(Elements[1], NumberStyles.Integer);
            TrackName = Elements[2];

            if (!Elements[3].Equals("", StringComparison.InvariantCultureIgnoreCase))
                SoundID = uint.Parse(Elements[3].Replace("0x", ""), NumberStyles.HexNumber);
            else
                SoundID = 0;

            if (Elements[5].Equals("\r\n", StringComparison.InvariantCultureIgnoreCase))
                return;

            if (!Elements[5].Equals("", StringComparison.InvariantCultureIgnoreCase))
                Argument = (HITTrackArguments)Enum.Parse(typeof(HITTrackArguments), Elements[5]);

            if (!Elements[7].Equals("", StringComparison.InvariantCultureIgnoreCase))
                ControlGroup = (HITControlGroup)Enum.Parse(typeof(HITControlGroup), Elements[7]);

            if (!Elements[(m_Version != 2) ? 11 : 12].Equals("", StringComparison.InvariantCultureIgnoreCase))
                DuckingPriority = int.Parse(Elements[(m_Version != 2) ? 11 : 12], NumberStyles.Integer);

            if (!Elements[(m_Version != 2) ? 12 : 13].Equals("", StringComparison.InvariantCultureIgnoreCase))
                Looped = (int.Parse(Elements[(m_Version != 2) ? 12 : 13], NumberStyles.Integer) != 0) ? true : false;

            if (!Elements[(m_Version != 2) ? 13 : 14].Equals("", StringComparison.InvariantCultureIgnoreCase))
                Volume = int.Parse(Elements[(m_Version != 2) ? 13 : 14], NumberStyles.Integer);

            m_Reader.Close();
        }

        private static void HandleClient(object client)
        {
            TcpClient tcpClient = (TcpClient)client;
            EndPoint remote = tcpClient.Client.RemoteEndPoint;

            NetworkStream clientStream = tcpClient.GetStream();
            int bytesRead;
            byte[] message = new byte[tcpClient.ReceiveBufferSize];

            ASCIIEncoding encoder = new ASCIIEncoding();

            while (true)
            {
                bytesRead = 0;
                string strMessage = "";
                try
                {
                    bytesRead = clientStream.Read(message, 0, tcpClient.ReceiveBufferSize);

                    strMessage = encoder.GetString(message, 0, bytesRead);
                    Console.WriteLine(String.Format("{1} just sent: {0}", strMessage, remote.ToString()));
                }
                catch
                {
                    //error = true;
                    break;
                }

                if (bytesRead == 0)
                    break;

            }
        }

        public static int Serialize(Kowhai.kowhai_node_t[] descriptor, byte[] data, out string target, Object getNameParam, GetSymbolName getName)
        {
            kowhai_get_symbol_name_t _getName = delegate(IntPtr param, UInt16 value)
            {
                return getName(getNameParam, value);
            };

            byte[] targetBuf;
            int targetBufferSize = 0x1000;
            int result;
            Kowhai.kowhai_tree_t tree;
            GCHandle h = GCHandle.Alloc(descriptor, GCHandleType.Pinned);
            tree.desc = h.AddrOfPinnedObject();
            GCHandle h2 = GCHandle.Alloc(data, GCHandleType.Pinned);
            tree.data = h2.AddrOfPinnedObject();
            do
            {
                targetBufferSize *= 2;
                targetBuf = new byte[targetBufferSize];
                result = kowhai_serialize(tree, targetBuf, ref targetBufferSize, IntPtr.Zero, _getName);
            }
            while (result == Kowhai.STATUS_TARGET_BUFFER_TOO_SMALL);
            h2.Free();
            h.Free();
            ASCIIEncoding enc = new ASCIIEncoding();
            target = enc.GetString(targetBuf, 0, targetBufferSize);
            return result;
        }

 public string ByteArrayToString(Byte[] bArray)
 {
     string str;
     System.Text.ASCIIEncoding enc = new System.Text.ASCIIEncoding();
     str = enc.GetString(bArray);
     return str;
 }

 //ASCII 码转字符
 public static string Chr(int asciiCode)
 {
     System.Text.ASCIIEncoding asciiEncoding = new System.Text.ASCIIEncoding();
                     byte[] byteArray = new byte[] { (byte)asciiCode };
                     string strCharacter = asciiEncoding.GetString(byteArray);
                     return (strCharacter);
 }

        /// <summary>
        /// Returns the Uuid from a series of bytes
        /// </summary>
        /// <param name="bytes"></param>
        /// <param name="offset"></param>
        /// <returns></returns>
        public static string BytesToUuid(AppendableByteArray bytes, int offset)
        {
            byte[] uuid = bytes.GetSubarray(offset, UUID_LEN);

            ASCIIEncoding encoding = new ASCIIEncoding();
            return encoding.GetString(uuid);
        }

 public string GetCommand()
 {
     System.Text.ASCIIEncoding enc = new ASCIIEncoding();
     byte[] buf = new byte[this.data.Length - 8];
     Array.Copy(this.data, 8, buf, 0, buf.Length);
     return enc.GetString(buf);
 }

        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 ();
                Console.WriteLine (encoder.GetString (message, 0, bytesRead));
                byte[] buffer = encoder.GetBytes("01");
                clientStream.Write(buffer, 0 , buffer.Length);
                clientStream.Flush();
            }

            tcpClient.Close ();
        }

        void DisplayMessageReceived(byte[] message)
        {
            ASCIIEncoding encoder = new ASCIIEncoding();
            string str = encoder.GetString(message, 0, message.Length);

            tbReceived.Text += str + "\r\n";
        }

        public void TC001_FileServerTest()
        {
            string user = Credentials.GenerateCredential();
            string password = Credentials.GenerateCredential();

            string tempPath = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString("N"));
            Directory.CreateDirectory(tempPath);

            File.WriteAllText(Path.Combine(tempPath, "test.txt"), "this is a test");

            int port = NetworkInterface.GrabEphemeralPort();

            FileServer fs = new FileServer(port, tempPath, "foobar", user, password);

            fs.Start();

            WebClient client = new WebClient();
            NetworkCredential credentials = new NetworkCredential(user, password);
            client.Credentials = credentials;
            byte[] data = client.DownloadData(String.Format("http://{0}:{1}/foobar/test.txt", "localhost", port));

            ASCIIEncoding encoding = new ASCIIEncoding();
            string retrievedContents = encoding.GetString(data);

            Assert.IsTrue(retrievedContents.Contains("this is a test"));

            //Thread.Sleep(6000000);

            fs.Stop();
        }

        public static string DoQuestion(string txt)
        {
            TcpClient client = new TcpClient();

            IPEndPoint serverEndPoint = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 8000);

            try
            {
                client.Connect(serverEndPoint);

                NetworkStream clientStream = client.GetStream();

                ASCIIEncoding encoder = new ASCIIEncoding();
                byte[] buffer = encoder.GetBytes(txt);

                clientStream.ReadTimeout = 1000;
                clientStream.Write(buffer, 0, buffer.Length);
                clientStream.Flush();

                buffer = new Byte[128];
                int size = clientStream.Read(buffer, 0, buffer.Length);

                client.Close();
                return encoder.GetString(buffer, 0, buffer.Length);
            }
            catch
            {
                return "failed";
            }
        }

    // Update is called once per frame
    void Update()
    {
        if (server.Pending())
        {
            //print ("comunica com cliente");
            cliente = server.AcceptSocket();
            cliente.Blocking = false;

            // operacoes de escrita e leitura com cliente
            byte [] mensagem = new byte[1024];
            cliente.Receive (mensagem); //leitura da mensagem enviada pelo cliente
            System.Text.ASCIIEncoding encoding = new System.Text.ASCIIEncoding ();
            strMessage = encoding.GetString (mensagem).ToString (); // string contendo mensagem recebida do cliente
            //print (strMessage);

            //prepara mensagem para envio
            byte[] envioBuffer = new byte[4];
            envioBuffer[0] = (byte)'a';
            envioBuffer[1] = (byte)'c';
            envioBuffer[2] = (byte)'k';
            envioBuffer[3] = 10;
            cliente.Send(envioBuffer); //envia mensagem ao cliente

        }

        // utiliza a mensagem recebida do cliente que foi armazenada
        // na variavel strMessage para atuar no objeto Cube da cena
        if (strMessage.Contains("noventa")) {
            meuservo.GetComponent<Servo_Motor_Limitado>().rotacao = 90; // rotaciona o servo em 90 graus
        }
    }