博客园_行囊

泛型约束

2012-01-26T07:23:00Z

在定义泛型类时，可以对客户端代码能够在实例化类时用于类型参数的类型种类施加限制。如果客户端代码尝试使用某个约束所不允许的类型来实例化类，则会产生编译时错误。这些限制称为约束。约束是使用 where 上下文关键字指定的。下表列出了六种类型的约束：

T：结构	类型参数必须是值类型。可以指定除 Nullable 以外的任何值类型.
T：类	类型参数必须是引用类型，包括任何类、接口、委托或数组类型。
T：new()	类型参数必须具有无参数的公共构造函数。当与其他约束一起使用时，new() 约束必须最后指定。
T：<基类名>	类型参数必须是指定的基类或派生自指定的基类。
T：<接口名称>	类型参数必须是指定的接口或实现指定的接口。可以指定多个接口约束。约束接口也可以是泛型的。
T：U	为 T 提供的类型参数必须是为 U 提供的参数或派生自为 U 提供的参数。这称为裸类型约束。

使用范例：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Collections;
using System.Runtime.Serialization;

namespace DictionaryGrammar
{
    public class WhereUse
    {
        public static void Main()
        {
            //未设置泛型构造函数时
            //MyDictionarySecond<int, Comparer> mds = new MyDictionarySecond<int, Comparer>();
            //设置了带有参数的泛型构造函数

            //demo
            MyDictionaryDefault<MyCompare> mdd = new MyDictionaryDefault<MyCompare>(new MyCompare());
            mdd.PrintString();

            //demo
            MyDictionaryU<Comparer, IComparer> aa = new MyDictionaryU<Comparer, IComparer>();
        }
    }
    /// <summary>
    /// 约束泛型类型
    /// </summary>
    /// <typeparam name="T">T被约束为结构类型</typeparam>
    /// <typeparam name="U">U被约束为类</typeparam>
    public class MyDictionary<T, U>
        where T : struct
        where U : class
    {
    }

    /// <summary>
    /// T被限制为U类型或继承自U类型
    /// </summary>
    /// <typeparam name="T">T被限制为U类型或继承自U类型</typeparam>
    /// <typeparam name="U">U被约束为类</typeparam>
    public class MyDictionaryU<T, U>
        where T : U
        where U : class
    {
    }

    /// <summary>
    /// 多重约束
    /// </summary>
    /// <typeparam name="T">U被约束为结构</typeparam>
    /// <typeparam name="U">U必须实现IComparer, ISerializable两个接口</typeparam>
    public class MyDictionarySecond<T, U>
        where T : struct
        where U : IComparer, ISerializable
    {
    }

    /// <summary>
    /// 设置默认构造函数
    /// <remarks>
    /// new约束指定泛型类声明中的任何类型参数都必须具有公共的无参数构造函数
    /// </remarks>
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public class MyDictionaryDefault<T>
        where T : IComparer, new()
    {
        /// <summary>
        /// 泛型的构造函数，由于设置了默认参数，所以在使用此泛型时，必须要传入参数。
        /// </summary>
        /// <param name="tVar"></param>
        public MyDictionaryDefault(T tVar)
        {
            Console.WriteLine("调用泛型构造函数,类型为{0}", this.GetType());
        }
        /// <summary>
        /// 泛型中方法
        /// </summary>
        public void PrintString()
        {
            Console.WriteLine("Use Default T");
        }
    }

    //自定义类
    public class MyCompare : IComparer
    {
        //public MyCompare()
        //{
        //}

        ////如果要实现带参数的构造函数，必须要明文写出无参构造函数
        //public MyCompare(string aa)
        //{
        //}

        public int Compare(object x, object y)
        {
            if (x == y)
            {
                return 0;
            }
            else
            {
                return -1;
            }
        }
    }
}

本文链接

泛型中Default用法

2012-01-26T03:06:00Z

在泛型中Default用来获取类型的默认值。请看下边示例代码。

public static void Main()
        {
            //结果为0
            int i = DefaultUse.GetObjedct<int>();
            //结果为0.0
            float f = DefaultUse.GetObjedct<float>();
            //结果为空
            DefaultUse du = DefaultUse.GetObjedct<DefaultUse>();
        }

        /// <summary>
        /// 泛型中Default用法
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
        public static T GetObjedct<T>()
        {
            //default用来获取一个类型的默认值
            return default(T);
        }

本文链接

c#等待所有子线程执行完毕方法

2012-01-10T02:02:00Z

当我们在使用线程中，你会发现主线结束后子线程的结果才显示出来。现在我要等待所以子线程结束，然后在显示结果，怎么做呢？

方法如下：

1、使用 ManualResetEvent，代码如下：

using System.Threading;

namespace ThreadStudy
{
    /// <summary>
    /// 等待所有子线程结束
    /// </summary>
    class StopAllWaitBySubThread
    {
        List<ManualResetEvent> manualEvents = new List<ManualResetEvent>();
        public void Main()
        {
            for (int i = 0; i < 5; i++)
            {
                ManualResetEvent mre = new ManualResetEvent(false);
                manualEvents.Add(mre);
                ThreadPool.QueueUserWorkItem(ThreadMethod, mre);
            }
            WaitHandle.WaitAll(manualEvents.ToArray());
            Console.WriteLine("Thread Finished!");
        }

        private void ThreadMethod(object obj)
        {
            //等待2秒，用于模拟系统在处理事情
            Thread.Sleep(2000);

            ManualResetEvent mre = (ManualResetEvent)obj;
            mre.Set();
            Console.WriteLine("Thread execute");
        }
    }
}

此种方法线程中只传递了信号，那要传递参数怎么办？可以采用类，将信号放在类中来解决，代码如下。

using System.Threading;

namespace ThreadStudy
{
    /// <summary>
    /// 等待所有子线程结束
    /// </summary>
    class StopAllWaitBySubThread
    {
        List<ManualResetEvent> manualEvents = new List<ManualResetEvent>();
        public void Main()
        {
            for (int i = 0; i < 5; i++)
            {
                ManualResetEvent mre = new ManualResetEvent(false);
                manualEvents.Add(mre);
                Param pra = new Param();
                pra.mrEvent = mre;
                pra.praData = i;
                ThreadPool.QueueUserWorkItem(ThreadMethod, pra);
            }
            WaitHandle.WaitAll(manualEvents.ToArray());
            Console.WriteLine("Thread Finished!");
        }

        private void ThreadMethod(object obj)
        {
            Thread.Sleep(2000);
            Param pra = (Param)obj;
            pra.mrEvent.Set();
            Console.WriteLine("Thread execute at {0}", pra.praData);
        }
    }

    public class Param
    {
        public ManualResetEvent mrEvent;
        public int praData;
    }
}

2、判断线程数

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

using System.Threading;

namespace ThreadStudy
{
    /// <summary>
    /// 判断当所有子线程执行完毕
    /// </summary>
    class ThreadPoolStop
    {
        public void Main()
        {
            for (int i = 0; i < 5; i++)
            {
                ThreadPool.QueueUserWorkItem(new WaitCallback(ThreadMethod), i);
            }
            int maxWorkerThreads, workerThreads;
            int portThreads;
            while (true)
            {
                /*
                 GetAvailableThreads()：检索由 GetMaxThreads 返回的线程池线程的最大数目和当前活动数目之间的差值。
                 而GetMaxThreads 检索可以同时处于活动状态的线程池请求的数目。
                 通过最大数目减可用数目就可以得到当前活动线程的数目，如果为零，那就说明没有活动线程，说明所有线程运行完毕。
                 */
                ThreadPool.GetMaxThreads(out maxWorkerThreads, out portThreads);
                ThreadPool.GetAvailableThreads(out workerThreads, out portThreads);
                if (maxWorkerThreads - workerThreads == 0)
                {
                    Console.WriteLine("Thread Finished!");
                    break;
                }
            }
        }

        private void ThreadMethod(object i)
        {

//模拟程序运行

            Thread.Sleep((new Random().Next(1, 4)) * 1000);
            Console.WriteLine("Thread execute at {0}", i.ToString());
        }
    }
}

3、使用Monitor

using System.Threading;

namespace ThreadStudy
{
    class StopAllSubThread
    {
        int _ThreadCount = 5;
        int finishcount = 0;
        object locker = new object();
        public void Main()
        {
            for (int i = 0; i < _ThreadCount; i++)
            {
                Thread trd = new Thread(new ParameterizedThreadStart(ThreadMethod));
                trd.Start(i);
            }
            lock (locker)
            {
                while (finishcount != _ThreadCount)
                {
                    Monitor.Wait(locker);//等待
                }
            }
            Console.WriteLine("Thread Finished!");
        }

        private void ThreadMethod(object obj)
        {
            //模拟执行程序
            Thread.Sleep(3000);
            Console.WriteLine("Thread execute at {0}", obj.ToString());
            lock (locker)
            {
                finishcount++;
                Monitor.Pulse(locker); //完成，通知等待队列,告知已完，执行下一个。
            }
        }
    }
}

本文链接

oracle中grant授权说明

2012-01-09T03:03:00Z

Oracle中授权有两种方式，系统权限授权及对象权限授权。

对于系统权限授权需要用DBA权限登陆，然后进行授权。如下边语句，"select any table"为系统权限，需要DBA账户才可以。

GRANT SELECT ANY TABLE TO gsc;

对于对象权限授权无需DBA权限。

--授权
grant select on hr.accounts to gsc;
--删除授权
revoke select on hr.accounts from gsc

本文链接

Ext.Net中Ext.net.DirectMethods无法找到DirectMethod

2011-12-14T06:25:00Z

在页面加载完成后，我需要用Js从父框架页中，取出数据，然后用Ext.net.DirectMethods更新后台缓存的数据。但始终报Ext.net.DirectMethods.xxxx为空。代码如下：

思考一下，决定改为将formLoad方法改为放到DocumentReady中。测试成功。估计在Ext.net中DirectMethod需要与Event一起使用。

    <ext:ResourceManager ID="ResourceManagerCallBack" runat="server">
        <Listeners>
            <DocumentReady Handler="formLoad()" />
        </Listeners>
    </ext:ResourceManager>

本文链接

用Json.NET将json字符串反序列化为json匿名对象

2011-12-14T05:38:00Z

首先定义一个匿名对对象，并序列化成Json，用于测试。如何将这个Josn字符串转换为JSON对象呢？如果先创建一个类的话，那就太累了。

var o = new
{
   a = 1,
   b = "Hello, World!",
   c = new[] { 1, 2, 3 },
   d = new Dictionary<string, int> { { "x", 1 }, { "y", 2 } }
};

var json = JsonConvert.SerializeObject(o);

第一种做法（匿名类）：

var anonymous = new { a = 0, b = String.Empty, c = new int[0], d = new Dictionary<string, int>() };
var o2 = JsonConvert.DeserializeAnonymousType(json, anonymous);

Console.WriteLine(o2.b);
Console.WriteLine(o2.c[1]);

第二种做法（匿名类）：

var o3 = JsonConvert.DeserializeAnonymousType(json, new { c = new int[0], d = new Dictionary<string, int>() });
Console.WriteLine(o3.d["y"]);

DeserializeAnonymousType 只是借助这个匿名对象参数(anonymous) 反射类型而已，也就是说它和反序列化结果并非同一个对象。正如 o3 那样，我们也可以只提取局部信息。

第三种做法（索引器）：

实际上，我们也可以直接反序列化为 JObject，然后通过索引器直接访问。JObject、JProperty 等都继承自 JToken，它重载了基元类型转换操作符，我们可以直接得到实际结果。

var o2 = JsonConvert.DeserializeObject(json) as JObject;

Console.WriteLine((int)o2["a"]);
Console.WriteLine((string)o2["b"]);
Console.WriteLine(o2["c"].Values().Count());
Console.WriteLine((int)o2["d"]["y"]);

转自：http://fanhuayi.blog.163.com/blog/static/397789201142651336395/

本文链接

js删除Array指定位置元素方法

2011-12-14T01:48:00Z

1.delete方法

delete arr[x]

这种方式数组长度不变,此时arr[1]变为undefined了,但是也有好处原来数组的索引也保持不变,此时要遍历数组元素可以才用。

遍历方法如下，这种遍历方式跳过其中undefined的元素。

for(index in arr){
document.write('arr[’+index+’]=’+arr[index]);
}

* 该方式IE4.o以后都支持了

2.数组对象splice方法

arr.splice(index,1);

这种方式数组长度相应改变,但是原来的数组索引也相应改变。splice中第一个参数是删除的起始索引(从0算起),在此是数组第二个参数是删除元素的个数。

遍历数组元素可以用普通遍历数组的方式,比如for,因为删除的元素在数组中并不保留。
* 该方法IE5.5以后才支持

另外，值得一提的是splice方法在删除数组元素的同时,还可以新增入数组元素比如arr.splice(1,1,’d',’e'),d,e两个元素就被加入数组arr了。结果数组变成arr:’a',’d',’e',’c’。

转自：http://www.cnblogs.com/liuzhixian/archive/2009/05/09/1453116.html

本文链接

IFrame网页加载完成事件

2011-12-09T05:46:00Z

网上别人的写法。

<html>
<head>
<script type="text/javascript">
    var iframe;
    function load() {
        iframe = document.getElementById("iframe");
        iframe. onload = iframe. onreadystatechange = iframeload;
        iframe.src = "http://www.baidu.com";
    }
    function iframeload() {
        if (!iframe.readyState || iframe.readyState == "complete") {
            alert("Local iframe is now loaded.");
        }
    }
</script>
</head>
<body onload="load()">
    <iframe id="iframe"></iframe>
</body>
</html>

我是直接接在Iframe中添加写OnLoad事件，代码如下：

本文链接

Ext.Net中清除iframe之前显示内容

2011-12-09T01:22:00Z

我在Ext.net Window中放入Iframe，用于调用跨域的网页。使用过程中发现调用下一个页面时，先前的页面会显示出来，然后才跳转到下一个页面，我决定清除先前的页面。

我的做法是，在Window的Close和Hide事件中增加移除方法。即在下一个页面显示前清除页面内容。(我先前做法是在调用下一个页面时，先清除页面内容，在显示，但这样仍然会显示先前页内容。)

具体代码：

1、Ext.Net Window Html代码

增加了Close及Hide事件。

        <ext:Window ID="WindowSite" runat="server" Icon="Application" Height="600px" Width="1000px"
            BodyStyle="background-color: #fff;" Padding="5" Modal="true" AutoShow="false"
            Hidden="true" AutoDoLayout="true" Maximizable="true" Maximized="false"
Html=" <iframe id='iframeSite' frameborder='0' width='100%' height='100%' src=''></iframe>">
            <Listeners>
                <Close Fn="WindowCloseOrHide" />
                <Hide Fn="WindowCloseOrHide" />
            </Listeners>
        </ext:Window>

2、编写清除方法

有两种，一种是直接设置空白页，代码如下。

var WindowCloseOrHide = function () {
    //清除ifame
    var iframeSite = document.getElementById("iframeSite");
    if (iframeSite) {
        iframeSite.src = "about:blank";"BlackPage.htm";
    }
}

另外一种，在项目建立一个页面，然后调用这个页面。我是建立“BlackPage.htm”页，在页加入等待信息，这样第次加载前都会显示等待信息，Html代码如下。

清除代码如下：

var WindowCloseOrHide = function () {
    //清除ifame
    var iframeSite = document.getElementById("iframeSite");
    if (iframeSite) {
        iframeSite.src = "about:blank";
        //        iframeSite.src = "BlackPage.htm";
    }
}

注：使用以下方式清除Ifrme内容是不行的，原因是跨域操作，代码如下。

var WindowCloseOrHide = function () {
    //清除ifame
    var iframeSite = document.getElementById("iframeSite");
    if (iframeSite) {
        iframeSite.document.write("<HTML>");
        iframeSite.document.write("<BODY>Loding……");
        iframeSite.document.write("</BODY>");
        iframeSite.document.write("</HTML>");
        iframeSite.document.close();
    }
}

本文链接

Response.Redirect出现Unable to evaluate expression because the code is optimized or a native frame……异常解决方法

2011-12-06T09:23:00Z

SYMPTOMS(症状)
    If you use the Response.End, Response.Redirect, or Server.Transfer method, a ThreadAbortException exception occurs. You can use a try-catch statement to catch this exception.

CAUSE(原因)
    The Response.End method ends the page execution and shifts the execution to the Application_EndRequest event in the application's event pipeline. The line of code that follows Response.End is not executed.
    This problem occurs in the Response.Redirect and Server.Transfer methods because both methods call Response.End internally.

RESOLUTION(解决)
    To work around this problem, use one of the following methods:
    •For Response.End, call the HttpContext.Current.ApplicationInstance.CompleteRequest method instead of Response.End to bypass the code execution to the Application_EndRequest event.
    •For Response.Redirect, use an overload, Response.Redirect(String url, bool endResponse) that passes false for the endResponse parameter to suppress the internal call to Response.End. For example:
   Response.Redirect ("nextpage.aspx", false);   //此种方法比较简单。

If you use this workaround, the code that follows Response.Redirect is executed.
•For Server.Transfer, use the Server.Execute method instead.

转自：http://hi.baidu.com/richard_cxs/blog/item/18024859d365ba2b2834f017.html

本文链接