博客园_TianFang

通过编程计算一个游戏的胜率

2012-02-06T15:13:00Z

以前庙会上经常有一个这样的游戏：

摆摊人拿出四种不同颜色的球，每种5个，然后放在一个袋子里，让观众摸出十个来，然后按颜色分类，统计每种颜色的个数，根据不同组合可以拿到不同的奖品，但如果是1234或3322这两种组合的时候，则需要给摆摊人几块钱。

其实一看到这个游戏就大致猜到这是个概率游戏了，1234和3322绝对是该规则下出现的较大的两个概率，摆摊人则无需使用任何作弊手段。但这两种组合的概率是多大，到一直没有细考虑过。其实上学的时候尝试算过，但当时数学没学好，愣是没算出来，便很快放弃了，现在上几年班后就自然更算不出来了。今天编了个小程序简单的算了个粗略的结果：

程序如下：

1     class Program
2     {
3         static void Main(string[] args)
4         {
5             var query = from i in Enumerable.Range(0, 100 * 10000)
6                         let result = Test()
7                         group result by result into g
8                         let value = new { Result = g.Key.ToString("0000"), Count = (double)g.Count() / 10000 }
9                         orderby value.Count descending
10                         select value;
11
12             foreach (var item in query)
13             {
14                 Console.WriteLine(item);
15             }
16         }
17
18         static Random rnd = new Random();
19         static int Test()
20         {
21             var numbers = Enumerable.Range(0, 20).OrderBy(_ => rnd.Next()).Take(10);    //随机抽取十个
22
23             var query = from n in numbers        //统计每种花色的张数
24                         let color = n % 4
25                         let value = n / 4
26                         group value by color into g
27                         select g.Count();
28
29             return query.OrderBy(i => i).Aggregate(0, (value, i) => value * 10 + i);
30         }
31     }

该程序的输出结果如下：

{ Result = 2233, Count = 32.5512 }
{ Result = 1234, Count = 32.4215 }
{ Result = 1333, Count = 10.8416 }
{ Result = 2224, Count = 10.766 }
{ Result = 1225, Count = 3.2447 }
{ Result = 0334, Count = 3.2204 }
{ Result = 1144, Count = 2.0338 }
{ Result = 0244, Count = 1.6388 }
{ Result = 1135, Count = 1.6385 }
{ Result = 0235, Count = 1.3121 }
{ Result = 0145, Count = 0.3284 }
{ Result = 0055, Count = 0.003 }

也就是说，3322和1234这两种组合将近占了65%，只要摆摊人把1333和2224这两种组合设置为比较小的奖项，基本上就稳赚不赔了，而最大奖0055，只有0.003%的概率，确实很难一见。

本文链接

通过NTP协议进行时间同步

2011-12-20T05:29:00Z

最近发现手机的时间不是很准了，便到网上下了一个同步时间的小程序，简单了看了一下它的原理，是通过NTP协议来实现校时的，就顺便学习了一下NTP协议，用C#写了个简单的实现。

NTP（Network Time Protocol，网络时间协议）是由RFC 1305定义的时间同步协议，用来在分布式时间服务器和客户端之间进行时间同步。

NTP工作原理

NTP的基本工作原理如下图所示。Device A和Device B通过网络相连，它们都有自己独立的系统时钟，需要通过NTP实现各自系统时钟的自动同步。为便于理解，作如下假设：

在Device A和Device B的系统时钟同步之前，Device A的时钟设定为10:00:00am，Device B的时钟设定为11:00:00am。
Device B作为NTP时间服务器，即Device A将使自己的时钟与Device B的时钟同步。
NTP报文在Device A和Device B之间单向传输所需要的时间为1秒。

Device A发送一个NTP报文给Device B，该报文带有它离开Device A时的时间戳，该时间戳为10:00:00am（T₁）。
当此NTP报文到达Device B时，Device B加上自己的时间戳，该时间戳为11:00:01am（T₂）。
当此NTP报文离开Device B时，Device B再加上自己的时间戳，该时间戳为11:00:02am（T₃）。
当Device A接收到该响应报文时，Device A的本地时间为10:00:03am（T₄）。

至此，Device A已经拥有足够的信息来计算两个重要的参数：

NTP报文的往返时延Delay=（T₄-T₁）-（T₃-T₂）=2秒。
Device A相对Device B的时间差offset=（（T₂-T₁）+（T₃-T₄））/2=1小时。

NTP的报文格式

NTP有两种不同类型的报文，一种是时钟同步报文，另一种是控制报文（仅用于需要网络管理的场合，与本文无关，这里不做介绍）。

NTP基于UDP报文进行传输，使用的UDP端口号为123；时钟同步报文封装在UDP报文中，其格式如下图所示。

主要字段的解释如下：

LI（Leap Indicator）：长度为2比特，值为“11”时表示告警状态，时钟未被同步。为其他值时NTP本身不做处理。
VN（Version Number）：长度为3比特，表示NTP的版本号，目前的最新版本为3。
Mode：长度为3比特，表示NTP的工作模式。不同的值所表示的含义分别是：0未定义、1表示主动对等体模式、2表示被动对等体模式、3表示客户模式、4表示服务器模式、5表示广播模式或组播模式、6表示此报文为NTP控制报文、7预留给内部使用。
Stratum：系统时钟的层数，取值范围为1～16，它定义了时钟的准确度。层数为1的时钟准确度最高，准确度从1到16依次递减，层数为16的时钟处于未同步状态，不能作为参考时钟。
Poll：轮询时间，即两个连续NTP报文之间的时间间隔。
Precision：系统时钟的精度。
Root Delay：本地到主参考时钟源的往返时间。
Root Dispersion：系统时钟相对于主参考时钟的最大误差。
Reference Identifier：参考时钟源的标识。
Reference Timestamp：系统时钟最后一次被设定或更新的时间。
Originate Timestamp：NTP请求报文离开发送端时发送端的本地时间。
Receive Timestamp：NTP请求报文到达接收端时接收端的本地时间。
Transmit Timestamp：应答报文离开应答者时应答者的本地时间。
Authenticator：验证信息。

NTP时间同步的实现

有了上述基础知识后，我们就可以实现自己的时间同步工具了，下文附了一个简单的C#的实现。

class NptClient

{

IPAddress ntpServer;

public NptClient(IPAddress ntpServer)

{

this.ntpServer = ntpServer;

}

public DateTime GetServerTime()

{

var startTime = DateTime.Now;

var ntpTime = NTPData.Test(ntpServer);

var recvTime = DateTime.Now;

var offset = ((ntpTime.ReceiveTimestamp - startTime) + (ntpTime.TransmitTimestamp - recvTime));

offset = offset.Subtract(TimeSpan.FromSeconds(offset.TotalSeconds / 2));

return recvTime + offset;

}

[StructLayout(LayoutKind.Sequential)]

class NTPData

{

byte header = 0;

byte Stratum = 1; //系统时钟的层数，取值范围为1～16，它定义了时钟的准确度

byte Poll = 1; //轮询时间，即两个连续NTP报文之间的时间间隔

byte Precision = 1; //系统时钟的精度

BigEndianUInt32 rootDelay;

BigEndianUInt32 referenceIdentifier;

BigEndianUInt32 ReferenceIdentifier;

public NtpTime ReferenceTimestamp { get; private set; }

public NtpTime OriginateTimestamp { get; private set; }

public NtpTime ReceiveTimestamp { get; private set; }

public NtpTime TransmitTimestamp { get; private set; }

public NTPData()

{

this.header = GetHeader();

}

byte GetHeader()

{

var LI = "00";

var VN = "011"; //NTP的版本号为3

var Mode = "011"; //客户模式

return Convert.ToByte(LI + VN + Mode, 2);

}

public static NTPData Test(IPAddress ntpServer)

{

var data = MarshalExtend.GetData(new NTPData());

var udp = new System.Net.Sockets.UdpClient();

udp.Send(data, data.Length, new IPEndPoint(ntpServer, 123));

var ep = new IPEndPoint(IPAddress.Any, 0);

var replyData = udp.Receive(ref ep);

return MarshalExtend.GetStruct<NTPData>(replyData, replyData.Length);

}

[StructLayout(LayoutKind.Sequential)]

class NtpTime

{

BigEndianUInt32 seconds;

BigEndianUInt32 fraction;

static readonly DateTime baseTime = new DateTime(1900, 1, 1, 0, 0, 0, DateTimeKind.Utc);

public static implicit operator DateTime(NtpTime time)

{

/* rfc1305的ntp时间中，时间是用64bit来表示的，记录的是1900年后的秒数（utc格式）

* 高32位是整数部分，低32位是小数部分 */

var milliseconds = (int)(((double)time.fraction / uint.MaxValue) * 1000);

return baseTime.AddSeconds(time.seconds).AddMilliseconds(milliseconds).ToLocalTime();

}

public override string ToString()

{

return ((DateTime)this).ToString("o");

}

当然，我这里只是在造重复轮子，网上是有不少功能完整的开源项目的。另外，如果对SNTPv4（RFC 2030）感兴趣的，可以参考一下这个页面上的实现——Simple Network Time (NTP) Protocol Client。

最后，附上几个可以使用（不保证，具体能用否还得看电信和方校长的心情）的NTP服务器：

133.100.11.8 prefer
210.72.145.44
203.117.180.36
131.107.1.10
time.asia.apple.com
64.236.96.53
130.149.17.21
66.92.68.246
18.145.0.30
clock.via.net
137.92.140.80
133.100.9.2
128.118.46.3
ntp.nasa.gov
129.7.1.66ntp-sop.inria.frserver
210.72.145.44(中国国家授时中心服务器IP地址)
ntp.sjtu.edu.cn (上海交通大学网络中心NTP服务器地址）
202.120.2.101 (上海交通大学网络中心NTP服务器地址）

本文链接

猜数字的算法的一个简单实现

2011-10-30T13:25:00Z

猜数字的算法的一个简单实现，用的最简单的算法，权当编程练习。

1     class GuessNumber
2     {
3         public static IEnumerable<int> Guess(Func<int, int> testHanlder)
4         {
5             var validNumers = Enumerable.Range(1, 9);    //有效数字范围为1-9
6             var candicateNum = from n1 in validNumers
7                                from n2 in validNumers
8                                from n3 in validNumers
9                                from n4 in validNumers
10                                where new int[] { n1, n2, n3, n4 }.Distinct().Count() == 4    //过滤掉有重复的数字
11                                select n1 * 1000 + n2 * 100 + n3 * 10 + n4;
12
13             while (true)
14             {
15                 var num = candicateNum.First();
16                 yield return num;
17
18                 var result = testHanlder(num);
19                 if (result == 40)
20                     yield break;
21
22                 candicateNum = candicateNum.Where(i => Test(i, num) == result);
23             }
24         }
25
26         public static IEnumerable<int> Guess(int num)
27         {
28             return Guess(i => Test(i, num));
29         }
30
31         //为了简单返回值为int型，如2A1B则返回21
32         public static int Test(int num1, int num2)
33         {
34             var value1 = num1.ToString("0000");
35             var value2 = num2.ToString("0000");
36
37             Contract.Assume((value1.Length == 4) && (value2.Length == 4));
38
39             var query = value1.Zip(value2, (ch1, ch2) => new
40                                     {
41                                         MatchA = (ch1 == ch2),
42                                         MatchB = (ch1 != ch2) && (value1.Contains(ch2))
43                                     }).ToArray();
44
45             var aCount = query.Count(i => i.MatchA);
46             var bCount = query.Count(i => i.MatchB);
47
48             return aCount * 10 + bCount;
49         }
50     }

本文链接

一种简单的可控并发粒度的TaskScheduler的实现

2011-10-05T10:47:00Z

当我们使用.net 4.0中的任务并行库的时候，有时候我们是需要自己控制并发粒度（调度线程数）的，这个时候往往就需要我们自己写TaskScheduler了，一个简单的实现如下：

public sealed class SimpleTaskScheduler : TaskScheduler, IDisposable
{
    BlockingCollection<Task> _tasks = new BlockingCollection<Task>();
    List<Thread> _threads = new List<Thread>();

    public SimpleTaskScheduler(int initNumberOfThreads = 3)
    {
        if (initNumberOfThreads < 1)
            throw new ArgumentOutOfRangeException();

        _threads.AddRange(Enumerable.Range(0, initNumberOfThreads).Select(_ => CreateThread()));
    }

    Thread CreateThread()
    {
        var thread = new Thread(() =>
        {
            foreach (var t in _tasks.GetConsumingEnumerable())
            {
                TryExecuteTask(t);
            }
        });

        thread.IsBackground = true;
        thread.Start();
        return thread;
    }

    protected override IEnumerable<Task> GetScheduledTasks()
    {
        //这个函数好像没有调过，返回null也不影响功能
        return _tasks.ToArray();
    }

    protected override void QueueTask(Task task)
    {
        _tasks.Add(task);
    }

    protected override bool TryExecuteTaskInline(Task task, bool taskWasPreviouslyQueued)
    {
        return TryExecuteTask(task);
    }

    public override int MaximumConcurrencyLevel { get { return _threads.Count; } }

    #region IDisposable 成员

    public void Dispose()
    {
        if (_tasks == null)        //防止重入
            return;

        _tasks.CompleteAdding();
        _threads.ForEach(t => t.Join());

        _tasks.Dispose();
        _tasks = null;
    }

    #endregion
}

这个类实现并不复杂，但其实用得还是比较多的，这里记录一下，以备后续查询。

PS：当前在Parallel.ForEach或Parallel.For等数据并发函数中可以通过ParallelOptions.MaxDegreeOfParallelism来控制并发粒度，但无法控制调度顺序。也可以通过类似这样的TaskScheduler来改变调度顺序。

本文链接

在WPF的WebBrowser控件中抑制脚本错误

2011-09-25T07:02:00Z

今天用WPF的WebBrowser控件的时候，发现其竟然没有ScriptErrorsSuppressed属性，导致其到处乱弹脚本错误的对话框，在MSDN上找到了如下解决方案：

1 static void SuppressScriptErrors(WebBrowser webBrowser, bool hide)
2 {
3     webBrowser.Navigating += (s, e) =>
4         {
5             var fiComWebBrowser = typeof(WebBrowser).GetField("_axIWebBrowser2", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic);
6             if (fiComWebBrowser == null)
7                 return;
8
9             object objComWebBrowser = fiComWebBrowser.GetValue(webBrowser);
10             if (objComWebBrowser == null)
11                 return;
12
13             objComWebBrowser.GetType().InvokeMember("Silent", System.Reflection.BindingFlags.SetProperty, null, objComWebBrowser, new object[] { hide });
14         };
15 }

本文链接

解决HttpWebRequest首次连接特别慢的问题

2011-09-18T14:41:00Z

今天把我以前做的一个程序升级到了.NET 4.0的版本，里面有一段通过HttpWebRequest获取html的代码，第一次运行特别慢，后续运行就快了。在网上搜了一下，在http://blog.csdn.net/rrrfff/article/details/6170653中找到了原因：.NET4.0中的默认代理是开启的,使用默认代理时，只有等待超时后才会绕过代理,从而导致第一次连接特别慢。（不知道微软为什么要把这个打开）

该文章中也提到了解决方案，一般有两种：

1. 在配置文件中(.config)中添加相应配置，关闭默认代理：

1 <?xml version="1.0"?>
2 <configuration>
3   <startup>
4     <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.0"/>
5   </startup>
6   <system.net>
7     <defaultProxy
8         enabled="false"
9         useDefaultCredentials="false" >
10       <proxy/>
11       <bypasslist/>
12       <module/>
13     </defaultProxy>
14   </system.net>
15 </configuration>

2. 通过编码的方式手动关闭Proxy。

1 var req = WebRequest.Create("http://www.google.com") ;
2 req.Proxy = null;

本文链接

Visual Studio 11 开发者预览版可以下载了

2011-09-17T09:51:00Z

Visual Studio 11 开发者预览版可以下载了，下载地址为：点击下载，提供的是旗舰版，目前支持中文和日文。

在虚拟机里装上去试了一下，界面上有少许微调，.net版本是4.5，新增特性比较少，除了支持async关键字外，没有什么太大亮点，而async前在visual studio 2010中也是能支持的。

至于metro界面程序，官方说是支持的，但我却没有找到相关的工程模板，不知是否得在win8里面安装才有这个功能。详细信息在在MSDN上也有专栏介绍——Visual Studio 11 Developer Preview。感兴趣的可以看一下。

总之这个版本没有什么大的亮点，感觉这个不是下一代的visual studio，而仅仅是为了支持win8的加强版本。自.net问世后，每次发布visual studio就会升级一次.net大版本，下一代visual studio应该会包含的.net 5.0吧，如果是这个版本的话卖点太少。

本文链接

一种在C#中实现类似多重继承功能的方法

2011-09-16T12:42:00Z

在面向对象语言中，我们往往通过继承来实现代码的复用，下面代码就演示了一个简单的Log功能的例子：

class Logger<T>

{

Subject<T> subject = new Subject<T>();

public void LogMessage(T msg)

{

subject.OnNext(msg);

}

public void Subscribe(Action<T> msgHanlder)

{

subject.Subscribe(msgHanlder);

}

class MyClass1:Logger<string>

{

}

class MyClass2:Logger<int>

{

}

然而，Log功能一般只是一种附加功能，在实际应用中，我们的子类往往需要从别的更复杂的类中继承而来，但此时如果要服用Log功能该怎么办呢？对于C++这种支持多重继承的语言来说，直接将Logger作为另一个父类即可附加该功能。然而，对于C#这种只支持单一父类的语言来说，一般只能采用组合的方式来复用Log功能了，基本方式如下：

class MyClass1 : Base1

{

Logger<string> logger = new Logger<string>();

public void LogMessage(string msg)

{

logger.LogMessage(msg);

}

public void Subscribe(Action<string> msgHanlder)

{

logger.Subscribe(msgHanlder);

}

class MyClass2 : Base2

{

Logger<string> logger = new Logger<string>();

public void LogMessage(string msg)

{

logger.LogMessage(msg);

}

public void Subscribe(Action<string> msgHanlder)

{

logger.Subscribe(msgHanlder);

}

这种方法带来的一个不好的地方在于：每一个子类都必须封装一遍LogMessage和Subscribe方法。如果子类较多，代码非常难看。好在C# 3.0带来了扩展属性的方法，通过它，则可以很容易类似C++之类的多重继承的功能。

interface ILogger<T>

{

}

class MyClass1 : ILogger<string>

{

}

class MyClass2 : ILogger<int>

{

}

static class LoggerExtend

{

static Subject<T> GetLoggerInfo<T>(this ILogger<T> logger)

{

throw new NotImplementedException();

}

public static void LogMessage<T>(this ILogger<T> logger, T msg)

{

logger.GetLoggerInfo().OnNext(msg);

}

public static void Subscribe<T>(this ILogger<T> logger, Action<T> msgHanlder)

{

logger.GetLoggerInfo().Subscribe(msgHanlder);

}

这种模式就很完美的解决了这一问题，子类只要实现ILogger这一接口，无需写任何代码，就拥有了Log功能。

但是，上面的方法还不能运行，最关键的GetLoggerInfo方法还没有实现，最直接的实现方法如下：

static Dictionary<object, object> dic = new Dictionary<object, object>();

static Subject<T> GetLoggerInfo<T>(this ILogger<T> logger)

{

object subject = null;

if (!dic.TryGetValue(logger, out subject))

{

subject = new Subject<T>();

dic.Add(logger, subject);

}

return subject as Subject<T>;

}

这样处理后，虽然代码功能看起来正常了，然而却存在一个非常大的隐患——logger无法释放：一旦logger使用后，在静态变量dic中就一直保存着该对象的引用，这样就永远无法释放。为了解决这一问题，我们必须将这个方法改一下，改成使用弱引用来维护logger引用，当logger释放后，其关联的subject对象也跟着一起释放。修改后的代码如下：

static class LoggerExtend

{

class WeakObject : WeakReference

{

public object Tag { get; private set; }

public WeakObject(object target,object tag)

: base(target)

{

this.Tag = tag;

}

static Dictionary<int, WeakObject> dic = new Dictionary<int, WeakObject>();

static Timer gcTimer = null;

static Subject<T> GetLoggerInfo<T>(this ILogger<T> logger)

{

lock (dic)

{

var key = logger.GetHashCode();

WeakObject weakobj = null;

if (!dic.TryGetValue(key, out weakobj))

{

var subject = new Subject<T>();

weakobj = new WeakObject(logger, subject);

dic.Add(key, weakobj);

Console.WriteLine("add "+key);

if (gcTimer == null)

gcTimer = new Timer(_ => GcWeakObject(), null, 0, 10000);

}

return weakobj.Tag as Subject<T>;

}

static void GcWeakObject()

{

lock (dic)

{

var deadObj = dic.Where(i => !i.Value.IsAlive).ToArray();

foreach (var item in deadObj)

{

if (item.Value.Tag is IDisposable)

(item.Value.Tag as IDisposable).Dispose();

dic.Remove(item.Key);

}

if (dic.Count == 0 && gcTimer != null)

{

gcTimer.Dispose();

gcTimer = null;

}

public static void LogMessage<T>(this ILogger<T> logger, T msg)

{

logger.GetLoggerInfo().OnNext(msg);

}

public static void Subscribe<T>(this ILogger<T> logger, Action<T> msgHanlder)

{

logger.GetLoggerInfo().Subscribe(msgHanlder);

}

最后总结一下吧，本文通过C#的扩展方法和弱引用，简单的实现了一个类似C++多重继承的功能，方便那种在大量地方使用的小功能的扩展。当然，这里的解决方案也不完美，一个很明显的问题就是扩展功能对象无法及时回收，需要等到计时器超时，也不支持手动Dispose。这种方式还是比较容易扩展的，我在这里只是抛砖引玉，如果谁有更好的方法，欢迎一起讨论。

本文链接

shuffle算法的一种简易实现

2011-09-12T10:58:00Z

shuffle算法一般也被称为洗牌算法，主要功能是将数组里的元素随机打乱，在扑克游戏及mp3播放器中比较常见。在C++的STL库中有专门的函数random_shuffle，在.net中就需要自己写了。不过这个算法并不复杂，一种常规写法如下：

static Random rnd = new Random();

public static IEnumerable<T> Shuffle<T>(IEnumerable<T> source)

{

var elements = source.ToArray();

for (int i = elements.Length - 1; i > 0; i--)

{

int swapIndex = rnd.Next(i + 1);

yield return elements[swapIndex];

elements[swapIndex] = elements[i];

}

yield return elements[0];

}

今天用google的时候发现了另一种写法：http://www.dotnetperls.com/shuffle-array。

不过原文里面的写法还稍微麻烦了点，简化一下其实就一句话，使用的时候甚至都不用单独作为函数。

static IEnumerable<T> Shuffle<T>(IEnumerable<T> source)

{

return source.OrderBy(_ => rnd.Next());

}

当然，后面这种算法的效率上要差一点，但用到shuffle算法的时候一般是不会用到大数组的，性能差异几乎可以忽略不计。这种不拘一格的思路确实值得学习一下。

本文链接

关于获取所有排列方式的算法

2011-09-12T08:44:00Z

今天又见有人问所有排列方式的问题，便随手写了个：

static IEnumerable<IEnumerable<int>> GetAllSequence(int n)

{

if (n == 1)

{

return Enumerable.Range(0, 1).Select(_ => new int[] { 1 });

}

else

{

var num = Enumerable.Range(n, 1);

return from seq in GetAllSequence(n - 1)

from count in Enumerable.Range(0, n)

select seq.Take(count).Concat(num).Concat(seq.Skip(count));

}

记得以前也写过过关于这个算法，搜了一下，是篇08年的老文章——一道关于排列组合的算法题。看了一下，虽然方法基本上是一样的，以前的代码写得比较青涩。看来这几年编程水平还是有点提高的。^_^

本文链接