C# EventArgs.GetType方法代码示例

        /// <summary>
        /// NotifyObserver has been done. Time to update the logapplication/device/resource.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected void ObserverNotified(object sender, EventArgs e)
        {
            //Message.Text += e.Message;
            #region gettype
            Type type = e.GetType();
            if (type.UnderlyingSystemType.Name.Equals("NotificationEventArgs"))
            {
                var notification = (LoggingBase.NotificationEventArgs)e;
                
                Trace.Write("ObserverNotified", notification.Message);

                Queue<string> messageQ = Session["ObserverNotified"] as Queue<string>;
                if (messageQ != null) messageQ.Enqueue(notification.Message);
                Session["ObserverNotified"] = messageQ;

                Message.Text = notification.Message;
            }

            Type senderType = sender.GetType();
            if (senderType.UnderlyingSystemType.Name.Equals("Timer"))
            {
                var timer = (System.Web.UI.Timer)sender;
                Message2.Text += DateTime.Now.ToShortTimeString() + "\tFrom " + timer.ToString() + "\n";
            }

            #endregion
        }

        public void MyEvent(object sender, EventArgs args)
        {
            //controlo gerador, o nome do evento gerado, a data/hora em que foi gerado e o argumento associado.

            Console.WriteLine("Controlo={0} || evento={1} || data={2} || argumento={3}"
                , ((Control)sender).Name, eventName, DateTime.Now, args.GetType().Name);
        }

 private void buttonClear_Click(object sender, EventArgs e)
 {
     if (e.GetType() == typeof(MouseEventArgs))
     {
         MouseEventArgs me = e as MouseEventArgs;
         textOutput.Text = "";
     }
 }

        void Dgv1Click(object sender, EventArgs e)
        {
            var ctrl = sender as Control;

            if (ctrl.Text != string.Empty && "Next|Prev|First|Last|Search".IndexOf(ctrl.Text) > -1
                || e.GetType().Name == "DataGridViewCellMouseEventArgs")
            {
                LoadDataSource();
            }

            if (e.GetType().Name == "DataGridViewCellEventArgs")
            {
                //This event means a row was selected by double-click
                const int RECORD_ID_OFFSET = 3;
                MessageBox.Show(dgv1.DataRowViewSelected[RECORD_ID_OFFSET].ToString());
            }
        }

 //public class textOutput
 //{
 //    public static string Text { get; internal set; }
 //}
 private void pictureBox1_Click(object sender, EventArgs e)
 {
     if(e.GetType() == typeof(MouseEventArgs))
     {
         MouseEventArgs me = e as MouseEventArgs;
         textOutput.Text += me.Location.ToString();
     }
 }

 protected void Application_BeginRequest(object sender, EventArgs e)
 {
     if (logger.IsDebugEnabled)
     {
         NDC.Push("BeginRequest");
         logger.DebugFormat("{0} sent {1}", sender, e.GetType());
         NDC.Pop();
     }
 }

 private void pictureBox1_Click(object sender, EventArgs e)
 {
     if(e.GetType() == typeof(MouseEventArgs))
     {
         MouseEventArgs me = e as MouseEventArgs;
         Coords co = new Coords(me.Location.ToString());
         coords.Add(co);
         textOutput.Text += me.Location.ToString() + " ";
     }
 }

        public void Write(Stream innerStream, EventArgs args)
        {
            if (innerStream == null) throw new ArgumentNullException("innerStream");
            if (args == null) throw new ArgumentNullException("args");

            using (var xw = XmlWriter.Create(innerStream, _xmlWriterSettings)) {
                new DataContractSerializer(args.GetType())
                    .WriteObject(xw, args);
            }
        }

        /// <summary>
        /// Serializes the specified event argument into a string representation.
        /// </summary>
        /// <param name="eventArgs">The <see cref="System.EventArgs"/> instance containing the event data.</param>
        /// <returns>The string representation of the specified event argument.</returns>
        public string Serialize(EventArgs eventArgs)
        {
            Ensure.ArgumentNotNull(eventArgs, "eventArgs");

            using (MemoryStream ms = new MemoryStream())
            {
                var serializer = new DataContractSerializer(eventArgs.GetType());
                serializer.WriteObject(ms, eventArgs);
                return Convert.ToBase64String(ms.ToArray());
            }
        }

        /// <summary>
        /// Serializes the specified event argument into a string representation.
        /// </summary>
        /// <param name="eventArgs">The <see cref="System.EventArgs"/> instance containing the event data.</param>
        /// <returns>The string representation of the specified event argument.</returns>
        public string Serialize(EventArgs eventArgs)
        {
            Ensure.ArgumentNotNull(eventArgs, "eventArgs");

            using (var sw = new StringWriter(CultureInfo.InvariantCulture))
            {
                var serializer = new XmlSerializer(eventArgs.GetType());
                serializer.Serialize(sw, eventArgs);
                return sw.ToString();
            }
        }

 /// <summary>
 ///     Checks <see cref="CanTrigger" /> before firing the event associated with this EventTrigger.
 /// </summary>
 protected override void OnEvent(EventArgs eventArgs)
 {
     var handledProperty = eventArgs.GetType().GetProperty("Handled");
     if (handledProperty != null)
     {
         handledProperty.SetValue(eventArgs, IsHandled, null);
     }
     if (CanTrigger)
     {
         base.OnEvent(eventArgs);
     }
 }

 static void Log(string title, object sender, EventArgs e)
 {
     Console.WriteLine("Event: {0}", title);
     Console.WriteLine("  Sender: {0}", sender);
     Console.WriteLine("  Arguments: {0}", e.GetType());
     foreach (PropertyDescriptor prop in
              TypeDescriptor.GetProperties(e))
     {
         string name = prop.DisplayName;
         object value = prop.GetValue(e);
         Console.WriteLine("    {0}={1}", name, value);
     }
 }

        private void OnEvent(object sender, EventArgs e)
        {
            bool handled = InvokeCommandOrAction();

            if (handled)
            {
                var handledProp = e.GetType().GetProperty("Handled");
                if (handledProp != null && handledProp.CanWrite && !Passthrough)
                {
                    handledProp.SetValue(e, true, null);
                }

            }
        }

    public void AddEvent(Control sender, string eventName, EventArgs args)
    {
      StringBuilder eventData;
      PropertyInfo[] properties;

      eventData = new StringBuilder();

      eventData.Append(DateTime.Now.ToLongTimeString());
      eventData.Append("\t");
      eventData.Append(sender.Name);
      eventData.Append(".");
      eventData.Append(eventName);
      eventData.Append(" (");

      properties = args.GetType().GetProperties();
      for (int i = 0; i < properties.Length; i++)
      {
        PropertyInfo property;
        string value;

        property = properties[i];

        try
        {
          object rawValue;

          rawValue = property.GetValue(args, null);

          value = rawValue != null ? rawValue.ToString() : null;
        }
        catch
        {
          value = null;
        }

        eventData.AppendFormat("{0} = {1}", property.Name, value);

        if (i < properties.Length - 1)
        {
          eventData.Append(", ");
        }
      }

      eventData.Append(")");

      this.Items.Add(eventData.ToString());
      this.TopIndex = this.Items.Count - (this.ClientSize.Height / this.ItemHeight);
    }

        private void form1_Click(object sender, EventArgs e)
        {
            MouseEventArgs args;

            if(e.GetType() != typeof(MouseEventArgs))
            {
                return;
            }

            args = (MouseEventArgs)e;

            foreach (TestLineBasedVertice v in Vertices)
            {
                if (v.TestMousePos(args.X, args.Y)) v.OnClick();
            }

            Refresh();
        }