8月 29

一直对正则匹配替换稀里糊涂的,这次做了一个测试,把问题搞明白

记录一下

        string regexString = "(匹配)";
        string regexContent = "做一个测试,匹配三次,匹配的是’匹配’两个字本身’";
        public void Main()
        {
            Regex regex = new Regex(regexString, RegexOptions.Singleline);
            Match match = regex.Match(regexContent);
            //做替换,"$1"表示的是被匹配的内容
            string result = regex.Replace(regexContent, "[$1]");
            System.Console.WriteLine(result);
            result = regex.Replace(regexContent, "**");
            System.Console.WriteLine(result);
        }

结果:

做一个测试,[匹配]三次,[匹配]的是'[匹配]’两个字本身’
做一个测试,**三次,**的是’**’两个字本身’

written by ocean

8月 23

(function () {
    var resolution = "分辨率:" + window.screen.width + "*" + window.screen.height;
    alert(resolution);
})();

(function () {
    var ua = window.navigator.userAgent;
    var osVersion = ua.split(";")[2];
    var osV = osVersion.substr(osVersion.length – 3, 3);
    var opName = "";
    switch (osV) {
        case "5.0":
            opName = "Win2000";
            break;
        case "5.1":
            opName = "WinXP";
            break;
        case "5.2":
            opName = "Win2003";
            break;
        case "6.1":
            opName = "Win 7";
            break;
        default:
            opName = "Other";
            break;
    }
    alert("操作系统:" + opName);
})();

(function () {
    var Sys = {};
    var ua = navigator.userAgent.toLowerCase();
    var s;
    (s = ua.match(/msie ([\d.]+)/)) ? Sys.ie = s[1] :
            (s = ua.match(/firefox\/([\d.]+)/)) ? Sys.firefox = s[1] :
            (s = ua.match(/chrome\/([\d.]+)/)) ? Sys.chrome = s[1] :
            (s = ua.match(/opera.([\d.]+)/)) ? Sys.opera = s[1] :
            (s = ua.match(/version\/([\d.]+).*safari/)) ? Sys.safari = s[1] : 0;
    if (Sys.ie)
        result = { Type: "ie", Ver: Sys.ie };
    else if (Sys.firefox)
        result = { Type: "firefox", Ver: Sys.firefox };
    else if (Sys.chrome)
        result = { Type: "chrome", Ver: Sys.chrome };
    else if (Sys.opera)
        result = { Type: "opera", Ver: Sys.opera };
    else if (Sys.safari)
        result = { Type: "safari", Ver: Sys.safari };
    else
        result = { Type: "unknown", Ver: "unknown" };
    //var result = {"Type":navigator.appName,"Ver":navigator.appVersion};

    alert("浏览器:" + result.Type + ",版本:" + result.Ver);
})();

(function () {
    var c;
    var cv = 16;
    if (cv != "Netscape")
        c = screen.colorDepth;
    else
        c = screen.pixelDepth;
    var cs = c;
    if (c == 4)
        cs = "4 位 16 色";
    if (c == 8)
        cs = "8 位 256 色";
    if (c == 16)
        cs = "16 位增强色";
    if (c > 16)
        cs = cs + " 位真彩色";
    alert(cs);
})();

written by ocean

8月 17

前一篇IEnumerable和IEnumerator的理解[原]介绍了这两个接口用来实现foreach

其实还可以用yield return

直接上代码和结果


一下为摘录的一部分,yield return对比前一篇

1。代码很简洁。其实这里多了一个yield return 语句,由于yield return 并不对应多余的il指令。所以编译器就会在编译的时候,生成一个实现Ienumator接口的类.并且自动维护该类的状态.比如movenext,

2. 使用yield return 很容易实现递归调用中的迭代器. 如果以上的问题,不使用yield return的话,可想而知.要么你先把所有的结果暂时放到一个对象集合中. 可是这样就以为着在迭代之前一定要计算号. 要么可能你的movenext 就相当的复杂了. .NET 编译生成的代码其实利用了state machine. 代码量也很大.

类似迭代的调用,比如二叉树遍历 用yield return 就很方便了.另外还有常说的pipeline模式也很方便了.

可是yield return 还是有一些缺陷.

比如如果GetFiles 有一个参数是ref 或者 out, 那这个state machine就很难去维护状态了. 事实上,yield return那是不支持方法带有ref或者out参数的情况.

written by ocean

8月 17

                       在现实应用中,对于集合以及枚举这些集合的需求非常普遍, 因此在.NET中集合所依赖的接口被设计为公共的。想要实现对象的枚举就必须继承IEnumerable接口。
                       public interface IEnumerable
                       {
                              public IEnumerator GetEnumerator();
                       }

它只有一个成员:GetEnumerator方法。该方法返回一个世纪的枚举器(enumerator)对象。那么要定义一个枚举器就要必须实现IEnumrator接口:
                       public interface IEnumerator
                       {
                              public Boolean MoveNext();
                              public Object Current { get; }
                              public void Reset();
                       }

                       也就是说如果我们希望一个类型支持枚举特性,那么我们就必须还要额外定义一个辅助类型来实现IEnumerator的所有方法。这个辅助类型通常被定义为一个Nested class声明在主类内部。这样在实现的时候我们发现,在app调用GetEnumerator()方法时,我们需要构造一个辅助类型的实例作为返回值。

看一段别人的总结,水平高的人应该理解更深吧。我先贴出来供以后参考。  

  1、一个Collection要支持foreach方式的遍历,必须实现IEnumerable接口(亦即,必须以某种方式返回IEnumerator object)。
                         2、IEnumerator object具体实现了iterator(通过MoveNext(),Reset(),Current)。
                         3、从这两个接口的用词选择上,也可以看出其不同:IEnumerable是一个声明式的接口,声明实现该接口的class是“可枚举(enumerable)”的,但并没有说明如何实现枚举器(iterator);IEnumerator是一个实现式的接口,IEnumerator object就是一个iterator。
                         4、IEnumerable和IEnumerator通过IEnumerable的GetEnumerator()方法建立了连接,client可以通过IEnumerable的GetEnumerator()得到IEnumerator object,在这个意义上,将GetEnumerator()看作IEnumerator object的factory method也未尝不可。

顺便给自己的网站做个广告

接龙大全网 http://www.jielongdaquan.com

现在说说自己的理解
                       如果某类想实现foreach,就必须实现接口IEnumerable的方法 ,也就是public IEnumerator GetEnumerator();这个方法。
                       但是GetEnumerator()这个方法返回IEnumerator接口,因此就必须有一个实现IEnumerator接口的三个方法的类
                       这样就有两种实现方式,
第一:分成两个类,其中一个实现IEnumerable接口的方法,其中给一个实现IEnumerator接口的方法
第二:合并在一个类里面,该类实现IEnumerable,IEnumerator两个接口的四个方法,这样的话GetEnumerator()方法只用返回本身就可以了

第一种实现方式,分成两个类的代码

第二种实现方式:合并成一个类的代码

两者调用方式一样

最后,输出结果

written by ocean

8月 17

扩展方法是C# 3.0中新加入的特性。MSDN中对扩展方法的定义是:扩展方法使您能够向现有类型“添加”方法,而无需创建新的派生类型、重新

编译或以其他方式修改原始类型。

扩展方法是静态方法~并且第一个参数要用this修饰~这个方法将作为第一个参数也就是带this参数的类的一个扩展方法~

定义如下

调用方法如下,就跟调用本身方法一样

显示结果如下


下面是对编写扩展方法要注意的几个原则(当然,仁者见仁、智者见智,这也是一家之言):

扩展方法有就近原则,也就是如果在你的程序里有两个一模一样的扩展方法,一个和你的使用类是处于同一命名空间里,另外一个处于别的命名空间里,这个时候会优先使用同一命名空间里的扩展方法,也就是说“血缘关系”越近,越被青睐。

很多人看到扩展方法也许眼里冒出金光,以后在设计的时候不管三七二十一,反正可以扩展。还有一些人会对类任意扩展,将以前一些作为”Helper”的方法统统使用扩展方法代替,注意的是扩展方法有“污染性”,所以我觉得在扩展的时候还是想想,是不是值得这样扩展。

在扩展的时候也不要对比较高层的类进行扩展,像我上面对object的扩展我觉得就是不可取的,object是所有类的基类,一经扩展,所有的类都被“污染”了。

在.net 2.0/3.0程序中使用扩展方法
.NET Framework 从2.0升级至3.0/3.5中,增加了不少编译器级别的语法糖,如var关键字、自动属性、Lambda表达式、扩展方法等等。

如果使用vs2008发布.net2.0程序时,除了扩展方法语法糖不可以直接使用。如果发布带扩展方法的程序则会编译出错。究

其原因,是因为编译器将那些方法(扩展方法)带上ExtensionAttribute属性, 而ExtensionAttribute这个类却存在于.NET Framework 3.5的程

序集中。
使用一个小技巧即可以使得带扩展方法的程序在.NET Framework 2.0/3.0时通过编译:自己定义这个ExtensionAttribute属性
namespace System.Runtime.CompilerServices
{
public class ExtensionAttribute : Attribute { }
}
这样, 即使不引用3.5版本的程序集, 也可以享受扩展方法带来的便利!

written by ocean

8月 17

<!–转载地址:http://www.cnblogs.com/bluedream2009/archive/2010/07/03/1770578.html–>

<!doctype html public "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<title>Test</title>
</head>
<body>

<style type="text/css">
#container table { border-collapse: collapse; border-spacing:0 }
#container { width:610px; height:205px; position:relative; overflow: hidden; margin:0 auto;}
#scroller { position:absolute; }
#page { position: absolute; float:right; left:476px; top:170px; width: 90px;}
#page li { float:left; cursor:pointer; list-style:none; width:15px; height:15px; line-height:15px; font-family:Arial; font-size:12px; margin:1px; text-align:center;background:url("http://hiphotos.baidu.com/ysuhy/abpic/item/2718f58cbf699d51b31bba1b.jpg") no-repeat scroll -15px 0 transparent;}
#page li.on {background:url("http://hiphotos.baidu.com/ysuhy/abpic/item/2718f58cbf699d51b31bba1b.jpg") no-repeat scroll 0 0 transparent;color:#FFFFFF;}
</style>

<div id="container">
<table id="scroller">
     <tbody>
         <tr>
             <td><img src="http://hiphotos.baidu.com/ysuhy/abpic/item/5703b07bc7aaeeae2e73b31b.jpg" width="610px" height="205px" alt="" /></td>
             <td><img src="http://hiphotos.baidu.com/ysuhy/abpic/item/b3cb7102ac9104af08fa931b.jpg" width="610px" height="205px" alt="" /></td>
             <td><img src="http://hiphotos.baidu.com/ysuhy/abpic/item/0422300151ed9ec4e950cd1b.jpg" width="610px" height="205px" alt="" /></td>
             <td><img src="http://hiphotos.baidu.com/ysuhy/abpic/item/602eb5fb3d95025da8d3111b.jpg" width="610px" height="205px" alt="" /></td>
             <td><img src="http://hiphotos.baidu.com/ysuhy/abpic/item/602eb5fb3d95025da8d3111b.jpg" width="610px" height="205px" alt="" /></td>
         </tr>
     </tbody>
</table>
<ul id="page"></ul>
</div>
<script>
    var QQ = function() {
        // 公用函数
        function T$(id) { return document.getElementById(id); }
        function T$$(root, tag) { return (root || document).getElementsByTagName(tag); }
        function $extend(des, src) { for (var p in src) { des[p] = src[p]; } return des; }
        function $each(arr, callback, thisp) {
            if (arr.forEach) { arr.forEach(callback, thisp); }
            else { for (var i = 0, len = arr.length; i < len; i++) callback.call(thisp, arr[i], i, arr); }
        }
        function currentStyle(elem, style) {
            return elem.currentStyle || document.defaultView.getComputedStyle(elem, null);
        }
        // 缓动类
        var Tween = {
            Quart: {
                easeOut: function(t, b, c, d) {
                    return -c * ((t = t / d – 1) * t * t * t – 1) + b;
                }
            },
            Back: {
                easeOut: function(t, b, c, d, s) {
                    if (s == undefined) s = 1.70158;
                    return c * ((t = t / d – 1) * t * ((s + 1) * t + s) + 1) + b;
                }
            },
            Bounce: {
                easeOut: function(t, b, c, d) {
                    if ((t /= d) < (1 / 2.75)) {
                        return c * (7.5625 * t * t) + b;
                    } else if (t < (2 / 2.75)) {
                        return c * (7.5625 * (t -= (1.5 / 2.75)) * t + .75) + b;
                    } else if (t < (2.5 / 2.75)) {
                        return c * (7.5625 * (t -= (2.25 / 2.75)) * t + .9375) + b;
                    } else {
                        return c * (7.5625 * (t -= (2.625 / 2.75)) * t + .984375) + b;
                    }
                }
            }
        }
        // 主类构造函数
        var scrollTrans = function(cid, sid, count, config) {
            var self = this;
            if (!(self instanceof scrollTrans)) {
                return new scrollTrans(cid, sid, count, config);
            }
            self.container = T$(cid);
            self.scroller = T$(sid);
            if (!(self.container || self.scroller)) {
                return;
            }
            self.config = $extend(defaultConfig, config || {});
            self.index = 0;
            self.timer = null;
            self.count = count;
            self.step = self.scroller.offsetWidth / count;
        };
        // 默认配置
        var defaultConfig = {
            trigger: 1, // 触发方式1:click other: mouseover
            auto: true, // 是否自动切换
            tween: Tween.Quart.easeOut, // 默认缓动类
            Time: 10, // 滑动延时
            duration: 50, // 切换时间
            pause: 3000, // 停顿时间
            start: function() { }, // 切换开始执行函数
            end: function() { } // 切换结束执行函数
        };
        scrollTrans.prototype = {
            constructor: scrollTrans,
            transform: function(index) {
                var self = this;
                index == undefined && (index = self.index);
                index < 0 && (index = self.count – 1) || index >= self.count && (index = 0);
                self.time = 0;
                self.target = -Math.abs(self.step) * (self.index = index);
                self.begin = parseInt(currentStyle(self.scroller)[‘left’]);
                self.change = self.target – self.begin;
                self.duration = self.config.duration;
                self.start();
                self.run();
            },
            run: function() {
                var self = this;
                clearTimeout(self.timer);
                if (self.change && self.time < self.duration) {
                    self.moveTo(Math.round(self.config.tween(self.time++, self.begin, self.change, self.duration)));
                    self.timer = setTimeout(function() { self.run() }, self.config.Time);
                } else {
                    self.moveTo(self.target);
                    self.config.auto && (self.timer = setTimeout(function() { self.next() }, self.config.pause));
                }
            },
            moveTo: function(i) {
                this.scroller.style.left = i + ‘px’;
            },
            next: function() {
                this.transform(++this.index);
            }
        };
        return {
            scroll: function(cid, sid, count, config) {
                window.onload = function() {
                    var frag = document.createDocumentFragment(), nums = [];
                    for (var i = 0; i < count; i++) {
                        var li = document.createElement(‘li’);
                        (nums[i] = frag.appendChild(document.createElement(‘li’))).innerHTML = i + 1;
                    }
                    T$(‘page’).appendChild(frag);
                    // 调用主类
                    var st = scrollTrans(cid, sid, count, config);
                    $each(nums, function(o, i) {
                        o[st.config.trigger == 1 ? ‘onclick’ : ‘onmouseover’] = function() { o.className = ‘on’; st.transform(i); }
                        o.onmouseout = function() { o.className = ”; st.transform(); }
                    });
                    st.start = function() {
                        $each(nums, function(o, i) {
                            o.className = st.index == i ? ‘on’ : ”;
                        });
                    };
                    st.transform();
                }
            }
        }
    } ();
QQ.scroll(‘container’, ‘scroller’, 5, {trigger: 0});
</script>
</body>
</html>

written by ocean

8月 14
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Diagnostics;
using System.Collections;
using System.IO;
using System.Net;

namespace Multithreading.Console
{
    public class MainClass
    {
        /// <summary>
        /// 设置在这个函数里
        /// </summary>
        private void Settings()
        {
            URL_DIC.Add("http://localhost:29649/Default.aspx", 50);
            URL_DIC.Add("http://localhost:29649/Default3.aspx", 10);
        }
        /// <summary>
        /// 启动该函数
        /// </summary>
        public void Start()
        {
            this.Settings();

            this.Init();

            this.Main();
        }
        /// <summary>
        /// 更改展示在这个函数里
        /// </summary>
        private void InitThreadFunc()
        {
            for (int index = 0; index < 100; index++)
            {
                //延迟500ms
                System.Threading.Thread.Sleep(500);
                Stopwatch stopwatch = new Stopwatch();
                try
                {
                    //stopwatch.Start();
                    string result = DownloadFromUrl(Url());
                    //stopwatch.Stop();
                    //System.Console.WriteLine(Thread.CurrentThread.Name + "耗时:" + stopwatch.ElapsedMilliseconds);
                    System.Console.Write(".");
                }
                catch (Exception ex)
                {
                    //stopwatch.Stop();
                    System.Console.Write("*");
                    //System.Console.WriteLine("——-" + Thread.CurrentThread.Name + “耗时:” + stopwatch.ElapsedMilliseconds);
                }
            }
        }

        /// <summary>
        /// 下载超时时间,单位ms(毫秒)
        /// </summary>
        int DOWNLOAD_TIMEOUT=1000;

        /// <summary>
        /// 最大线程数,并发量
        /// </summary>
        int MAX_THREAD = 100;

        /// <summary>
        /// 每个线程下载的数量
        /// </summary>
        int EVERY_THREAD_DOWNLOAD_COUNT=100;

        int MAX_DENOMINATOR=10000;

        private void Init()
        {
            int max = 0;
            foreach (KeyValuePair<string, int> item in URL_DIC)
            {
                max += item.Value;
            }

            int n = 0;
            foreach (KeyValuePair<string, int> item in URL_DIC)
            {
                int length = (int)(((decimal)item.Value) / ((decimal)max) * MAX_DENOMINATOR);
                for (int index = 0; index < length; index++)
                {
                    dic.Add(n, item.Key);
                    n++;
                }
            }
            MAX_DENOMINATOR = dic.Count;
        }

        /// <summary>
        /// 测试访问的URL第一个参数为URL,第二个参数为所占的比例
        /// </summary>
        Dictionary<string,int> URL_DIC=new Dictionary<string,int>();

        private List<Thread> threads = new List<Thread>();  
        Dictionary<int,string> dic=new Dictionary<int,string>();

       
        public void Main()
        {
            for (int index = 0; index < MAX_THREAD; index++)
            {
                Thread thread = new Thread(new ThreadStart(InitThreadFunc));
                thread.Name = "thread" + index;
                threads.Add(thread);
                thread.Start();
            }
            while (threads.Count > 0)
            {
                foreach (Thread thread in threads)
                {
                    if (thread.Join(1000))
                    {
                        threads.Remove(thread);
                        break;
                    }
                }
            }
        }
        /// <summary>
        /// 此函数随机取地址需要改进一下
        /// </summary>
        /// <returns></returns>
        private string Url()
        {
            Random random = new Random();
            return dic[random.Next(0, MAX_DENOMINATOR)];
        }

        public string DownloadFromUrl(string url)
        {
            try
            {
                if (!url.Contains("http://"))
                { url = "http://" + url; }
                url.TrimEnd(new char[] { '\\', '/' });
                HttpWebRequest request = WebRequest.Create(url) as HttpWebRequest;
                request.Timeout = DOWNLOAD_TIMEOUT;
                HttpWebResponse response = request.GetResponse() as HttpWebResponse;
                System.IO.Stream responseStream = response.GetResponseStream();
                System.IO.StreamReader reader = new System.IO.StreamReader(responseStream, Encoding.UTF8);
                string srcString = reader.ReadToEnd();

                return srcString;
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

    }
}

written by ocean

8月 14
var Tools = {
     BrowserInfo: function() {
         var Sys = {};
         var ua = navigator.userAgent.toLowerCase();
         var s;
         (s = ua.match(/msie ([\d.]+)/)) ? Sys.ie = s[1] :
         (s = ua.match(/firefox\/([\d.]+)/)) ? Sys.firefox = s[1] :
         (s = ua.match(/chrome\/([\d.]+)/)) ? Sys.chrome = s[1] :
         (s = ua.match(/opera.([\d.]+)/)) ? Sys.opera = s[1] :
         (s = ua.match(/version\/([\d.]+).*safari/)) ? Sys.safari = s[1] : 0;
         if (Sys.ie) return { Type: "ie", Ver: Sys.ie };
         if (Sys.firefox) return { Type: "ff", Ver: Sys.firefox };
         if (Sys.chrome) return { Type: "gc", Ver: Sys.chrome };
         if (Sys.opera) return { Type: "op", Ver: Sys.opera };
         if (Sys.safari) return { Type: "sf", Ver: Sys.safari };
         return { Type: "unknown", Ver: "unknown" };
     }
}
alert(Tools.BrowserInfo().Type);
alert(Tools.BrowserInfo().Ver);

written by ocean

8月 13

         首先讲一下UNION的工作原理,当使用UNION语句时,它的功能与在结果集上SELECT DISTINCT类似,也就是说使用UNION时它会首先合并两个结果集,然后执行一个类似于SELECT DISTINCT的操作,以避免重复行的出现。

         这个过程在两上结果集没有任何重复行的情况下也会进行DISTINCT处理,所以如果我们确认在UNION的两个结果集确实存在重复行,并且要消除重复行的出现时,就可以使用UNION.

         从另一方面来说,如果我们知道在结果集中并不会存在重复行,或者说出现重复行对我们的应用程序没有什么影响时,我们应该使用UNION ALL语句来替代 UNION语句,UNION ALL和UNION相比的优点在于它并不会对两个结果集进行SELECT DISTINCT操作,这样可以节省SQL Server 的资源使用。

written by ocean

8月 13

<regex name="Iphone Home Page"><![CDATA[{‘OriginalPrice’\:'(?<OriginalPrice>.*?)’,’FinalPrice’\:'(?<FinalPrice>.*?)’,’SoldOut’\:'(?<SoldOut>.*?)’,’DailyDealTotalOriginalPrice’\:'(?<DailyDealTotalOriginalPrice>.*?)’,’DailyDealTotalFinalPrice’\:'(?<DailyDealTotalFinalPrice>.*?)’,’DailyDealCount’\:'(?<DailyDealCount>.*?)’}]]></regex>

foreach (RegexStringList regexStringList in m_RegexListConfig.RegexStringList)
                {
                    if (regexStringList.RegexName.ToLower() == "iphone home page")
                    {
                        Regex regex = new Regex(regexStringList.RegexString, RegexOptions.Singleline);
                        Match match = regex.Match(server.ResponseContent);
                        
                        if (!string.IsNullOrEmpty(match.Groups["DailyDealCount"].Value))  
                        {
                            server.DailyDealTotalFinalPrice = int.Parse(match.Groups["DailyDealCount"].Value);
                        }
                    }
                }

written by ocean