WinLogs

using System.Diagnostics;
using System;

namespace ConsoleApplication1
{
    class WinLogs
    {
        private static void Main44()
        {
            EventLog log = new EventLog("MyEvent"); //System 默认是Application
            //  首先应判断日志来源是否存在，一个日志来源只能同时与一个事件绑定
            if (!EventLog.SourceExists("MyApplicationCCC")) //向非Application事件写日志信息时，需要先使用CreateEventSource方法将事件源添加到当前事件中
            {
                EventLog.CreateEventSource("ApplicationCCC", "MyEvent");
            }
            try
            {
                log.Source = "ApplicationCCC11";
                log.WriteEntry("处理信息1", EventLogEntryType.Information);
                //log.WriteEntry("处理信息2", EventLogEntryType.Information);
                throw new System.IO.FileNotFoundException("readme.txt文件未找到");

                //if (EventLog.Exists("MyEvent"))
                //{
                //    EventLog log = new EventLog("MyEvent");
                //    foreach (EventLogEntry entry in log.Entries)
                //    {
                //        textBox1.Text += entry.Message + ":";
                //    }
                //}
            }
            catch (System.IO.FileNotFoundException exception)
            {
                log.WriteEntry(exception.ToString(), EventLogEntryType.Error);
            }

        }
    }

    class C66 : IDisposable
    {
        public void UseLimitedResource()
        {
            Console.WriteLine("Using limited resource...");
        }

        void IDisposable.Dispose()
        {
            Console.WriteLine("Disposing limited resource.");
        }
    }

    class Program44
    {
        static void Main11()
        {
            using (C66 c = new C66())
            {
                c.UseLimitedResource();
            }
            Console.WriteLine("Now outside using statement.");
            Console.ReadLine();
        }

        static void ValueTypeDemo()
        {
            SomeRef r1 = new SomeRef();//分配在托管堆
            SomeVal v1 = new SomeVal();//堆栈上
            r1.x = 5;//解析指针
            v1.x = 5;//在堆栈上修改

            SomeRef r2 = r1;//仅拷贝引用(指针)
            SomeVal v2 = v1;//先在堆栈上分配,然后拷贝成员

            r1.x = 8;//改变了r1,r2的值
            v1.x = 9;//改变了v1,没有改变v2
        }

    }

    //引用类型(''class'' 类类型)
    class SomeRef
    {
        public int x;
    }

    //值类型(''struct'')
    struct SomeVal
    {
        public Int32 x;
    }

    public struct Shoe44
    {
        public string Color;
    }
    //public class Shoe
    //{
    //    public string Color;
    //}
    public class Shoe : ICloneable
    {
        public string Color;
        public object Clone()
        {
            Shoe newShoe = new Shoe();
            newShoe.Color = Color.Clone() as string;
            return newShoe;
        }
    }

    public class Dude : IDisposable
    {
        public string Name;
        public Shoe RightShoe;
        public Shoe LeftShoe;

        public Dude gfd()
        {
            Dude newPerson = new Dude();
            newPerson.Name = Name;
            newPerson.LeftShoe = LeftShoe;//assign heap address Dude是引用类型，而且由于结构Shoe的两个字段是Dude类的成员，所以它们都被放在了堆上。
            newPerson.RightShoe = RightShoe;//使用的Shoe是引用类型而非值类型，当引用类型的内容被拷贝时实际上只拷贝了该类型的指针(并没有拷贝实际的对象)，
            return newPerson;
        }

        public Dude CopyDude()
        {
            Dude newPerson = new Dude();
            newPerson.Name = Name;
            newPerson.LeftShoe = LeftShoe.Clone() as Shoe;
            newPerson.RightShoe = RightShoe.Clone() as Shoe;
            return newPerson;
        }

        public override string ToString()
        {
            return (Name + " : Dude!, I have a " + RightShoe.Color + " shoe on my right foot, and a " + LeftShoe.Color + " on my left foot.");
        }
        public static void Main11()
        {
            using (Dude Bill = new Dude())//类中使用using()块来实现IDisposable接口,能够使我们在清理垃圾对象时不需要写额外的代码来强制GC回收我们的对象。
            {
                Bill.Name = "Bill";
                Bill.LeftShoe = new Shoe();
                Bill.RightShoe = new Shoe();
                Bill.LeftShoe.Color = Bill.RightShoe.Color = "Blue";//请注意为System.String类分配的操作符("="号),它实际上是将string型对象进行克隆，所以你不必担心会发生引用拷贝, 我们应该"克隆"引用类型，"拷贝"值类型。如果我们打算将我们的对象用于拷贝，那么我们的类应该实现IClonealbe借口，这样能够使引用类型仿效值类型的行为。

                Dude Ted = Bill.CopyDude();
                Ted.Name = "Ted";
                Ted.LeftShoe.Color = Ted.RightShoe.Color = "Red";
                Console.WriteLine(Bill.ToString());
                Console.WriteLine(Ted.ToString());
            }
        }
        public void Dispose()
        {
            // CLEAN UP HERE!
        }
    }

    //--------------------
    //静态类仅包含静态成员。它们是密封的。 不能包含实例构造函数。静态类不能包含构造函数，但仍可声明静态构造函数以分配初始值或设置某个静态状态.静态成员通常用于表示不会随对象状态而变化的数据或计算,例如，数学库可能包含用于计算正弦和余弦的静态方法。对于只对输入参数进行运算而不获取或设置任何内部实例字段的方法集，静态类可以方便地用作这些方法集的容器。

    // 无论对一个类创建多少个实例，它的静态成员都只有一个副本。静态方法和属性不能访问其包含类型中的非静态字段和事件，并且不能访问任何对象的实例变量（除非在方法参数中显式传递）。 更常见的做法是声明具有一些静态成员的非静态类，而不是将整个类声明为静态类。静态字段有两个常见的用法：一是记录已实例化对象的个数，二是存储必须在所有实例之间共享的值。
    public class dddd
    {

        public static void dd()
        {

        }

    }

    public class dddd55 : dddd
    {

    }

}