dada7357

就技术面而言,本人的体会是:一定要走出小级别的技术认识误区.
      
       现在就拿周K线图来谈谈本人对"均线系统的拐头和粘合"的认识:
       先看06年9月的中旬,均线粘合朝上走了,可以进场了.
       07年的2-3月,均线没有拐头向下,周K线也仅仅是横盘,因此可以继续持有.
       07年6月下旬,均线开始拐头向下了,那就需要退场了.
       07年8月初,均线又粘合了,又该进场了.直至11月中旬均线拐头退场.一路下来都没有见到均线粘合朝上(因此说,08年整一年不碰票的人才是最大赢家).
       09年2月,均线又粘合了.当然是又该进场了.
       8月7日后该怎么操作就不言而语了.
       回头查历史走势,可操作性大概率形态基本如此.人们都说做股票没有确定性,都是在赌.我却不以为然.
       做趋势的追随者,只做趋势,不做差价。做一个合格的交易者，不做赌徒。
       注重技术面小级别的起伏,无非就是心态上的贪婪和恐惧的交替(因此才产生70%人的亏损).8月7日以来的可操作性,本人认为不强,在日线级别的均线系统走坏的情况下,能操作盈利的人可谓是凤毛麟角,是小概率事件.因此必须走出小级别的技术认识误区.
       技术不是万能的,但是万万不可没有的.耐心等待技术趋势走好才是最重要的,尤其要等到周线级别的形态走好.耐心往往跟你的涨号资金成正比.
       采取基本面和技术面相结合来判断市场是比较完美的.但是技术面往往提前反映了人们对基本面的预期(再者,基本面的不可把握性及不真实的可能性是非常大的).
       因此,只有在级别比较大一点的稳定的趋势下操作,才可以减少盲目性和不确定性,赢的概率就相对大的多.
       如把以上周线图上的进退位置拆分到日线级别上来看,应该什么都清楚了.                                     

protected void Page_Load(object sender, EventArgs e)
        {
            DataTable dt = new DataTable();
            dt.Columns.Add(new DataColumn("HI", typeof(System.Int32)));
            dt.Columns.Add(new DataColumn("OK", typeof(System.String)));
            dt.Columns.Add(new DataColumn("HAI", typeof(System.String)));
            dt.Rows.Add(1, "dlkjsf", "ldsjflskjd");
            dt.Rows.Add(2, "dlkjsf", "ldsjflskjd");
            dt.Rows.Add(3, "dlkjsf", "ldsjflskjd");
            dt.Rows.Add(4, "dlkjsf", "ldsjflskjd");
            Form1.MapDataTableToObjectList<A_Record>(dt);

        }
        public static List<TType> MapDataTableToObjectList<TType>(DataTable dt) where TType : new()
        {
            System.Data.DataColumnCollection columns = dt.Columns;
            int iColumnCount = columns.Count;
            int i;
            int j;
            TType ttype = new TType();
            Type elementType;
            elementType = ttype.GetType();
            System.Reflection.PropertyInfo[] publicProperties = elementType.GetProperties();
            List<TType> result = new List<TType>();
            if (publicProperties.Length == iColumnCount)
            {
                foreach (DataRow currentRow in dt.Rows)
                {
                    for (i = 0; i < iColumnCount; i++)
                    {
                        for (j = 0; j < publicProperties.Length; j++)
                        {
                            if (columns[i].ColumnName == publicProperties[j].Name)
                            {
                                publicProperties[j].SetValue(ttype, currentRow[i], null);
                            }
                        }
                    }
                    result.Add(ttype);
                    ttype = new TType();
                }
            }
            else
            {
                result = null;
            }
            return result;
        }

        public class A_Record
        {
            private int hi;
            private string ok;
            protected string hai;

            public int HI
            {
                get { return hi; }
                set { hi = value; }
            }

            public string OK
            {
                get { return ok; }
                set { ok = value; }
            }

            public string HAI
            {
                get { return hai; }
                set { hai = value; }
            }
        }

    这是本人第一次写博客，做了好久的潜水员，只因自知自己没有什么能力，又不敢在各位高手面前出丑。第一编写可能不是什么新东西，请大家不要见笑。

    若名委托，相信有好多人都用过。只是在观察者模式中，希望把所执行的函数返回的值进行比较，我都是第一次使用到。
就比如下边就是一个比较。

这是一个委托类

namespace UnityDemo
{
    public delegate bool ObserverDelegate<T>(T t);

    public class test
    {
        private  ObserverDelegate<int> observerList;

        public event ObserverDelegate<int> Observers
        {
            add //注册观察者
            {
                observerList += value;
            }
            remove//移除观察者
            {
                observerList -= value;
            }
        }

        public bool onHandler(int i)
        {
            //if (this.observerList != null)
            //{
            //    observerList(i);
            //}

            foreach (ObserverDelegate<int> od in this.observerList.GetInvocationList())
            {
                if (!od(i))
                {
                    return false ;
                }
            }

            return true;
           
        }
    }
}

这是进行比较的实例：

namespace UnityDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            test t = new test();

            t.Observers += new ObserverDelegate<int>(x=> {

                Console.Write("is larger 5:" + (x > 4).ToString () +"\n");

                return x > 4;  });

            t.Observers += new ObserverDelegate<int>(x =>
            {

                Console.Write("is larger 6:" + (x > 6).ToString () + "\n");

                return x > 6;
            });

            t.Observers += new ObserverDelegate<int>(x =>
            {

                Console.Write("is larger 5:" + (x > 4).ToString() + "\n");

                return  x > 4;
            });

            bool r = t.onHandler(5);

            Console.ReadLine();
        }
    }
}

每个若名方法都要经过onHandler这个函数，而委托方法都会使用GetInvocationList这个函数来得到若名方法，从而来比较！