《程序员的第一年》---------- 消息队列与Cookie相关整理

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;

namespace Cookie的增删改查
{
    /// <summary>
    /// Cookie 通常限制为 4096 字节，并且每个站点最多可存储 20 个 Cookie
    /// </summary>
    public partial class test : System.Web.UI.Page
    {
        protected void Page_Load(object sender, EventArgs e)
        {
            
        }

        protected void Button1_Click(object sender, EventArgs e)
        {

        }

        /// <summary>
        /// Cookie的添加
        /// 第一个 Cookie，Cookies 集合的值是直接设置的。
        /// 可以通过这种方式向集合添加值，因为 Cookies 
        /// 是从 NameObjectCollectionBase 类型的专用集合派生的 
        /// </summary>
        protected void OneCookie()
        {
            Response.Cookies["UserName"].Value = "xiaobing";
            Response.Cookies["UserName"].Expires = DateTime.Now.AddDays(1);

            HttpCookie aCookie = new HttpCookie("lastVisit");
            aCookie.Value = DateTime.Now.ToString();
            aCookie.Expires = DateTime.Now.AddDays(1);
            Response.Cookies.Add(aCookie);//集合添加值的形式添加COOKIE

        }

        /// <summary>
        /// 多值Cookie
        /// 带子键的Cookie
        /// </summary>
        protected void MultipleValued()
        {
            Response.Cookies["userInfo"]["userName"] = "xiaobing";
            Response.Cookies["userInfo"]["lastVisit"] = DateTime.Now.ToString();
            Response.Cookies["userInfo"].Expires = DateTime.Now.AddDays(1);

            HttpCookie aCookie = new HttpCookie("userInfo");
            aCookie.Values["userName"] = "taomeng";
            aCookie.Values["lastVisit"] = DateTime.Now.ToString();
            aCookie.Expires = DateTime.Now.AddDays(1);
            Response.Cookies.Add(aCookie);
        
        }

        /// <summary>
        /// 将 Cookie 限制到某个文件夹或应用程序
        /// 所产生的效果是 Cookie 只能用于 Application1 文件夹或虚拟根目录中的页面
        /// </summary>
        protected void AppointFolderCookie()
        {
            HttpCookie appCookie = new HttpCookie("AppCookie");
            appCookie.Value = "written " + DateTime.Now.ToString();
            appCookie.Expires = DateTime.Now.AddDays(1);
            appCookie.Path = "/Application1";
            Response.Cookies.Add(appCookie);
             
        }

        /// <summary>
        /// 限制 Cookie 的域范围
        /// 当以此方式设置域时，Cookie 将仅可用于指定的子域中的页面
        /// </summary>
        protected void DomainCookie()
        {
            Response.Cookies["domain"].Value = DateTime.Now.ToString();
            Response.Cookies["domain"].Expires = DateTime.Now.AddDays(1);
            Response.Cookies["domain"].Domain = "support.contoso.com";
          
            //多个子域间共享的 Cookie
            //Response.Cookies["domain"].Domain = "contoso.com";

        }

        /// <summary>
        /// 读取Cookie值 
        /// </summary>
        protected void ReadCookie()
        {
            //如果该 Cookie 不存在，将会收到 NullReferenceException 异常。 
            if (Request.Cookies["userName"] != null)
                Label1.Text = Server.HtmlEncode(Request.Cookies["userName"].Value);

            if (Request.Cookies["userName"] != null)
            {
                HttpCookie aCookie = Request.Cookies["userName"];
                Label1.Text = Server.HtmlEncode(aCookie.Value);
            }

            //读取 Cookie 中子键值的方法与设置该值的方法
            if (Request.Cookies["userInfo"] != null)
            {
                Label1.Text =
                    Server.HtmlEncode(Request.Cookies["userInfo"]["userName"]);

                //Label2.Text =
                //    Server.HtmlEncode(Request.Cookies["userInfo"]["lastVisit"]);
                DateTime dt;
                dt = DateTime.Parse(Request.Cookies["userInfo"]["lastVisit"]);
            }


            //Cookie 中的子键被类型化为 NameValueCollection 类型的集合。因此，获取单个子键的另一种方法是获取子键集合，然后再按名称提取子键值
            if (Request.Cookies["userInfo"] != null)
            {
                System.Collections.Specialized.NameValueCollection
                    UserInfoCookieCollection;

                UserInfoCookieCollection = Request.Cookies["userInfo"].Values;
                Label1.Text =
                    Server.HtmlEncode(UserInfoCookieCollection["userName"]);
                Label2.Text =
                    Server.HtmlEncode(UserInfoCookieCollection["lastVisit"]);
            }


        }

        /// <summary>
        /// Cookie的修改
        /// </summary>
        protected void UpdateCookie()
        {
            int counter;
            if (Request.Cookies["counter"] == null)
                counter = 0;
            else
            {
                counter = int.Parse(Request.Cookies["counter"].Value);
            }
            counter++;

            Response.Cookies["counter"].Value = counter.ToString();
            Response.Cookies["counter"].Expires = DateTime.Now.AddDays(1);
        }

        /// <summary>
        /// 删除Cookie
        /// </summary>
        protected void DeleteCookie()
        {
            HttpCookie aCookie;
            string cookieName;
            int limit = Request.Cookies.Count;
            for (int i = 0; i < limit; i++)
            {
                cookieName = Request.Cookies[i].Name;
                aCookie = new HttpCookie(cookieName);
                aCookie.Expires = DateTime.Now.AddDays(-1);
                Response.Cookies.Add(aCookie);
            }

            //移除单个子键
            string subkeyName;
            subkeyName = "userName";
              aCookie = Request.Cookies["userInfo"];
            aCookie.Values.Remove(subkeyName);
            aCookie.Expires = DateTime.Now.AddDays(1);
            Response.Cookies.Add(aCookie);
        }


    }
}


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Messaging;

//将消息发送到队列和从队列接收消息。

namespace 发送到队列和从队列接收消息
{

    // This class represents an object the following example 
    // sends to a queue and receives from a queue.
    public class Order
    {
        public int orderId;
        public DateTime orderTime;
    };

    /// <summary>
    /// Provides a container class for the example.
    /// </summary>
    public class MyNewQueue
    {

        //**************************************************
        // Provides an entry point into the application.
        //		 
        // This example sends and receives a message from
        // a queue.
        //**************************************************

        public static void Main()
        {
            // Create a new instance of the class.
            MyNewQueue myNewQueue = new MyNewQueue();

            // Send a message to a queue.
            myNewQueue.SendMessage();
             Send a message to a queue.
            //myNewQueue.SendMessage();
            // Receive a message from a queue.
            myNewQueue.ReceiveMessage();

            Console.Read();
            return;
        }


        //**************************************************
        // Sends an Order to a queue.
        //**************************************************

        public void SendMessage()
        {

            // Create a new order and set values.
            Order sentOrder = new Order();
            sentOrder.orderId = 3;
            sentOrder.orderTime = DateTime.Now;

            // Connect to a queue on the local computer.
            MessageQueue myQueue = new MessageQueue(".\\Private$\\myQueue"); 
            if (!MessageQueue.Exists(".\\Private$\\myQueue"))
            {
                MessageQueue.Create(".\\Private$\\myQueue");
            }

            // Send the Order to the queue.
            myQueue.Send(sentOrder);

            return;
        }


        //**************************************************
        // Receives a message containing an Order.
        //**************************************************

        public void ReceiveMessage()
        {
            // Connect to the a queue on the local computer.连接到一个队列在本地计算机。
            MessageQueue myQueue = new MessageQueue(".\\Private$\\myQueue");
            

            //获取或设置格式化程序，该格式化程序用于将对象序列化为从队列读取或写入队列的消息体，
            //或者用于将从队列读取或写入队列的消息体反序列化为对象。
            myQueue.Formatter = new XmlMessageFormatter(new Type[] { typeof(发送到队列和从队列接收消息.Order) });

            try
            {
                // Receive and format the message. 
                Message myMessage = myQueue.Receive();
                Order myOrder = (Order)myMessage.Body;

                // Display message information.
                Console.WriteLine("Order ID: " +
                    myOrder.orderId.ToString());
                Console.WriteLine("Sent: " +
                    myOrder.orderTime.ToString());
            }

            catch (MessageQueueException)
            {
                // Handle Message Queuing exceptions.
            }

            // Handle invalid serialization format.
            catch (InvalidOperationException e)
            {
                Console.WriteLine(e.Message);
            }

            // Catch other exceptions as necessary.

            return;
        }
    }
}



using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Messaging; //引用此项

namespace 消息队列_MessageQueue_
{
    /// <summary>
    /// 使用各种路径名语法类型创建新的 MessageQueue 对象
    /// </summary>
    public   class Program
    {
        public    static void Main(string[] args)
        {
            Program myNewQueue = new Program();

            myNewQueue.SendPublic();
            myNewQueue.SendPrivate();
            myNewQueue.SendByLabel();
            myNewQueue.SendByFormatName();
            myNewQueue.MonitorComputerJournal();
            myNewQueue.MonitorQueueJournal();
            myNewQueue.MonitorDeadLetter();
            myNewQueue.MonitorTransactionalDeadLetter();


        }

        /// <summary>
        /// 引用公共消息队列
        /// </summary>
        public void SendPublic()
        {
            MessageQueue myQueue = new MessageQueue(".\\myQueue");
            myQueue.Send("Public queue by path name.");

            return;
        
        }
        // References private queues.
        public void SendPrivate()
        {
            MessageQueue myQueue = new
                MessageQueue(".\\Private$\\myQueue");
            myQueue.Send("Private queue by path name.");

            return;
        }

        // References queues by label.
        public void SendByLabel()
        {
            MessageQueue myQueue = new MessageQueue("Label:TheLabel");
            myQueue.Send("Queue by label.");

            return;
        }

        // References queues by format name.
        public void SendByFormatName()
        {
            MessageQueue myQueue = new
                MessageQueue("FormatName:Public=5A5F7535-AE9A-41d4" +
                "-935C-845C2AFF7112");
            myQueue.Send("Queue by format name.");

            return;
        }

        // References computer journal queues.计算机日记
        public void MonitorComputerJournal()
        {
            MessageQueue computerJournal = new
                MessageQueue(".\\Journal$");
            while (true)
            {
                Message journalMessage = computerJournal.Receive();
                // Process the journal message.
            }
        }

        // References queue journal queues.队列日记
        public void MonitorQueueJournal()
        {
            MessageQueue queueJournal = new
                MessageQueue(".\\myQueue\\Journal$");
            while (true)
            {
                Message journalMessage = queueJournal.Receive();
                // Process the journal message.
            }
        }

        // References dead-letter queues.
        public void MonitorDeadLetter()
        {
            MessageQueue deadLetter = new
                MessageQueue(".\\DeadLetter$");
            while (true)
            {
                Message deadMessage = deadLetter.Receive();
                // Process the dead-letter message.
            }
        }

        // References transactional dead-letter queues.
        public void MonitorTransactionalDeadLetter()
        {
            MessageQueue TxDeadLetter = new
                MessageQueue(".\\XactDeadLetter$");
            while (true)
            {
                Message txDeadLetter = TxDeadLetter.Receive();
                // Process the transactional dead-letter message.处理死信消息事务。
            }
        }

    }
}