博客园_海鸥航迹

Windows批处理中的等待技巧

2011-08-19T15:08:00Z

1、直接使用Windows 2003资源工具包中的Sleep.exe 程序，它在全系列Windows中都可以运行；

2、使用下面的技巧

@ping 127.0.0.1 –n 12 >nul

由于Windows Ping目标地址是间隔1秒，上面的指令相当于等候12秒；

本文链接

The Ice::Current Object

2011-08-09T14:46:00Z

The Ice::Current Object

服务器端Servant骨架方法（skeleton operation）都有一个Ice::Current类型的参数，这个对象定义如下:

module Ice {

local dictionary<string, string> Context;

enum OperationMode { Normal, \Nonmutating, \Idempotent };

local struct Current {

ObjectAdapter adapter;

Connection con;

Identity id;

string facet;

string operation;

OperationMode mode;

Context ctx;

int requestId;

};

这个对象提供了服务器端实现当前正在执行的这个操作的一些信息访问入口：

adapter：

adapter成员提供对object adapter的访问，请求就是通过它被分派的。依次的，adapter提供对communicator的访问，通过getCommunicator操作，如此，就能访问到ICE一切环境信息，如配置属性。

con

con成员提供对接收请求的连接的访问，参见37.5.1；

id成员提供当前请求的对象标识，实际就是当前servant的对象标识。

Facet

提供对当前请求的facet的访问；

Operation

包含了要调用的方法的名称。注意操作名也可能是Ice::Object 上的方法，诸如ice_ping,ice_isA（checkCast方法会调用ice_isA）等等；

Mode

代表当前操作的调用模式；

Ctx

包含了当前调用的上下文；

RequestId

Ice协议的请求ID；

本文链接

ICE代理的固有方法

2011-08-09T14:45:00Z

Table 32.1. The semantics of core proxy methods.
Method	Description	Remote
ice_isA	Returns true if the remote object supports the type indicated by the id argument, otherwise false. This method can only be invoked on a twoway proxy.	Yes
ice_ping	Determines whether the remote object is reachable. Does not return a value.	Yes
ice_ids	Returns the type ids of the types supported by the remote object. The return value is an array of strings. This method can only be invoked on a twoway proxy.	Yes
ice_id	Returns the type id of the most-derived type supported by the remote object. This method can only be invoked on a twoway proxy.	Yes
ice_getHash	Returns a hash value for the proxy for C++. For other language mappings, use the built-in hash method.	No
ice_getCommunicator	Returns the communicator that was used to create this proxy.	No
ice_toString	Returns the string representation of the proxy.	No
ice_identity	Returns a new proxy having the given identity.	No
ice_getIdentity	Returns the identity of the Ice object represented by the proxy.	No
ice_adapterId	Returns a new proxy having the given adapter id.	No
ice_getAdapterId	Returns the proxy’s adapter id, or an empty string if no adapter id is configured.	No
ice_endpoints	Returns a new proxy having the given endpoints.	No
ice_getEndpoints	Returns a sequence of Endpoint objects representing the proxy’s endpoints. See Section 36.5.2 for more information.	No
ice_endpointSelection	Returns a new proxy having the given selection policy (random or ordered). See Section 36.3.1 for more information.	No
ice_getEndpointSelection	Returns the endpoint selection policy for the proxy.	No
ice_context	Returns a new proxy having the given request context. See Section 32.12 for more information on request contexts.	No
ice_getContext	Returns the request context associated with the proxy. See Section 32.12 for more information on request contexts.	No
ice_facet	Returns a new proxy having the given facet name. See Chapter 33 for more information on facets.	No
ice_getFacet	Returns the name of the facet associated with the proxy, or an empty string if no facet has been set. See Chapter 33 for more information on facets.	No
ice_twoway	Returns a new proxy for making twoway invocations.	No
ice_isTwoway	Returns true if the proxy uses twoway invocations, otherwise false.	No
ice_oneway	Returns a new proxy for making oneway invocations (see Section 32.14).	No
ice_isOneway	Returns true if the proxy uses oneway invocations, otherwise false.	No
ice_batchOneway	Returns a new proxy for making batch oneway invocations (see Section 32.16).	No
ice_isBatchOneway	Returns true if the proxy uses batch oneway invocations, otherwise false.	No
ice_datagram	Returns a new proxy for making datagram invocations (see Section 32.15).	No
ice_isDatagram	Returns true if the proxy uses datagram invocations, otherwise false.	No
ice_batchDatagram	Returns a new proxy for making batch datagram invocations (see Section 32.16).	No
ice_isBatchDatagram	Returns true if the proxy uses batch datagram invocations, otherwise false.	No
ice_secure	Returns a new proxy whose endpoints may be filtered depending on the boolean argument. If true, only endpoints using secure transports are allowed, otherwise all endpoints are allowed.	No
ice_isSecure	Returns true if the proxy uses only secure endpoints, otherwise false.	No
ice_preferSecure	Returns a new proxy whose endpoints are filtered depending on the boolean argument. If true, endpoints using secure transports are given precedence over endpoints using non-secure transports. If false, the default behavior gives precedence to endpoints using non-secure transports.	No
ice_isPreferSecure	Returns true if the proxy prefers secure endpoints, otherwise false.	No
ice_compress	Returns a new proxy whose protocol compression capability is determined by the boolean argument. If true, the proxy uses protocol compression if it is supported by the endpoint. If false, protocol compression is never used.	No
ice_timeout	Returns a new proxy with the given timeout value in milliseconds. A value of ‑1 disables timeouts. See Section 32.13 for more information on timeouts.	No
ice_router	Returns a new proxy configured with the given router proxy. See Chapter 42 for more information on routers.	No
ice_getRouter	Returns the router that is configured for the proxy (null if no router is configured).	No
ice_locator	Returns a new proxy with the specified locator. See Chapter 38 for more information on locators.	No
ice_getLocator	Returns the locator that is configured for the proxy (null if no locator is configured).	No
ice_locatorCacheTimeout	Returns a new proxy with the specified locator cache timeout. When binding a proxy to an endpoint, the run time caches the proxy returned by the locator and uses the cached proxy while the cached proxy has been in the cache for less than the timeout. Proxies older than the timeout cause the run time to rebind via the locator. A value of 0 disables caching entirely, and a value of ‑1 means that cached proxies never expire. The default value is ‑1.	No
ice_getLocatorCacheTimeout	Returns the locator cache timeout value in seconds.	No
ice_collocationOptimized	Returns a new proxy configured for collocation optimization. If true, collocated optimizations are enabled. The default value is true.	No
ice_isCollocationOptimized	Returns true if the proxy uses collocation optimization, otherwise false.	No
ice_connectionId	Returns a new proxy having the given connection identifier. See Section 36.3.3 for more information.	No
ice_getConnectionId	Returns the connection id, or an empty string if no connection id has been configured.	No
ice_getConnection	Returns an object representing the connection used by the proxy. If the proxy is not currently associated with a connection, the Ice run time attempts to establish a connection first. See Section 36.5 for more information.	No
ice_getCachedConnection	Returns an object representing the connection used by the proxy, or null if the proxy is not currently associated with a connection. See Section 36.5 for more information.	No
ice_connectionCached	Enables or disables connection caching for the proxy. See Section 36.3.4 for more information	No
ice_isConnectionCached	Returns true if the proxy uses connection caching, otherwise false.	No
ice_flushBatchRequests	Sends a batch of operation invocations synchronously or asynchronously (see Section 32.16).	Yes
begin_ice_flushBatchRequests
ice_invoke	Allows dynamic invocation of an operation without the need for compiled Slice definitions. Requests can be sent synchronously (see Section 35.3.1) or asynchronously (see Section 35.4).	Yes
begin_ice_invoke

本文链接

C# Tips 2则

2011-08-07T13:42:00Z

C# Textbox Auto Scroll To End ScrollToCaret Scrolling Textbox
Many of my sample C# codes,
I use textbox to write the results.

When textbox is multiline property set to true, and when I insert text into it,
I want it to auto scroll to the last line.

Here is a simple way to auto scrolling textbox.

textbox1.SelectionStart = textbox1.Text.Length;
textbox1.ScrollToCaret();
textbox1.Refresh();

Textbox SelectionStart will force the textbox control to select the last part of the text,
and ScrollToCaret() function will auto scroll textbox to the end.

C# Convert Hexadecimal to Binary String Conversion

There is no need to code tons of codes, loops, to convert hex to binary string. Convert.ToInt32 function is very useful for this purpose.
Let's convert the "A" character to binary format. private string hex2binary(string hexvalue)
{
string binaryval = "";
binaryval = Convert.ToString(Convert.ToInt32(hexvalue, 16), 2);
return binaryval;
}When we call hex2binary("A"); it will return "1010" similar samples below;
hex2binary("1a"); will return "11010";
hex2bianry("1a2c"); will return "1101000101100"; and so on.
Keep in mind that this hex to binary conversion style uses 32 bit integer number.

本文链接

Configuring log4net with VS2010 and .Net 4.0

2011-08-02T13:28:00Z

Configuring log4net with VS2010 and .Net 4.0

After spending a few hours this morning trying to get log4net working with a project, I decided to share my findings. I chased a lot of dead-ends for what wound up being a fairly simple solution. Here is a quick article to save both myself, and maybe you, some time in the future.

Get Log4Net

Go to http://logging.apache.org/log4net/ and get the latest version. Add the project file to your solution. Then right-click that project, choose the build tab and…

Step 1: Set the log4net conditional compilation symbols replacing NET_1_0 with NET_4_0.

Log4Net Requires Full .Net Access

That means you cannot use “client profile”. log4net was originally written to log web services. As such it expects to have a lot of server-side classes available, even though most of those classes are never instantiated.

Step 2: Build Your Application & The Log4Net component under .Net 4.0, not .Net 4.0 Client Profile

Make Log4Net Less Secure

The .Net 4.0 assemblies are more secure by default. You need to override this. As I’m not a .Net development guru I’m not really certain what the differences mean, but Google is your friend (and mine) here, so if you are concerned (and you should be before launching a public app) then search the Internet to find out what this mean. In the meantime…

Step 3: Make log4net assembly less secure, add
[assembly: System.Security.SecurityRules(System.Security.SecurityRuleSet.Level1)]
to the log4net AssemblyInfo.cs file.

Done.

That’s it, the first steps for getting a log4net component into your application. Now you can follow some of the development & deployment document on the Apache site:

http://logging.apache.org/log4net/release/manual/configuration.html

编译好的for .net 4.0 的log4net库文件下载：

log4net for .net 4.0 : http://files.cnblogs.com/sgsoft/log4Net_4.0.zip

本文链接

IoC Container Benchmark - Unity, Windsor, StructureMap and Spring.NET

2011-07-28T13:23:00Z

There are a number of inversion of control containers out there so I thought it would be an interesting experiment to do a simple benchmark. There are different ways that one can instantiate a type in .NET, for example via the new operator, Activator, GetUninitializedObject and Dynamic Method. The performance difference between these methods are in some cases quite high, maybe the same is true for these IoC containers? Granted IoC containers do more than just create objects so other factors will probably play a big role in the results.

So here are the contestants:

Castle Windsor
- Part of the popular Castle Project.
- First introduced in 2004
StructureMap
- Sourceforge project maintained and created by Jeremy D. Miller
Spring.NET
- Inspired by the spring java framework
- First introduced in 2004, www.springframework.net
Unity
- Created by the Microsoft Patterns Practices team
- First released in April 2008
- Project homepage on codeplex

I have been using Castle Windsor since 2005 and I think it is the best of the bunch, so I guess I am unconsciously biased toward Windsor. However I will try to make this benchmark as objective as I can.

The scenario for this test:

Have each IoC container resolve a UserController 1000 000 times
The UserController will have two constructor dependencies
Run the test with transient (new instance for each resolve) and singleton components

The UserController looks like this:

public class UserController

{

private IUserRepository repository;

private IAuthentificationService authService;

public UserController(IUserRepository repository, IAuthentificationService authService)

{

this.repository = repository;

this.authService = authService;

}

I have also a general container interface that the benchmark engine will use. Each container will implement this interface.

public interface IContainer

{

string Name { get; }

T Resolve<T>();

void SetupForTransientTest();

void SetupForSingletonTest();

}

All tests used the latest released version of each library. Before you interpret these charts please observe that the measurement is for one million component resolves which means the actual time difference between each container is actually very small.

Here are the results when all components were setup as singletons:

Here are the results when all components were setup as transient:

So what does these charts tell us? Lets take the biggest difference in the transient case, Spring.NET took 44.149 seconds and Unity took 8.164 seconds, what is the actual difference when resolving a single instance?

Spring.NET : 44.149 / 1000000 = 0.000044149 seconds

Unity : 8.164 / 1000000 = 0.000008164 seconds

So the actual difference is only about 36 microseconds. Another way to put these values into perspective is to compare against the new operator. I created a NewOperatorContainer with a resolve method that looks like this:

public T Resolve<T>()

{

object o = new UserController(new LdapUserRepository(), new DefaultAuthentificationService());

return (T) o;

}

OK, comparing the above with an inversion of control container is like comparing apples to oranges, an IoC handles so much more than just object creation. Also an IoC cannot use the new operator directly but must use one of the other methods. My guess is that all IoC containers in this test uses an approach which involve IL Generation which if cashed comes close to using the new operator directly. Anyway I think it will show just how small the difference between the real IoC containers are. In order to visualize this I needed to invert the values so that high means fast and low means slow.

http://lh3.ggpht.com/torkel.odegaard/SALo6OJA3yI/AAAAAAAAAWg/Nhrvuby1VUE/s1600-h/IoCInversed[5].png

Update: The above chart can be very misleading. The x-axis is not seconds but 1/s. I hope it shows that the difference between the containers are very small compared to instantiating the objects manually.

OK, can we draw any conclusion from the test? Well I think we can say that performance should not be an issue when choosing one of these IoC containers. The difference is too small. When you choose which container to use you should consider other aspects, like how invasive the container is to they way you want to work.

For the complete code: IoCBenchmark.zip

Posted by Torkel Ödegaard at 6:46 AM

Labels: Benchmarks, C#, Castle, IoC

13 comments:

Anonymous said...

IMHO your last graph is very misleading. why do you use the inverse values? use the usual values and point out how tiny the "new" value is - or if you feel like the inverse is beneficial at least label your axis correctly.
otherwise nice article

April 14, 2008 1:20 PM

Torkel Ödegaard said...

Yes, you are right. I also feel that the last graph is too misleading. I will correct it when I get home from work.

April 14, 2008 1:25 PM

Joshua said...

I would interested to see how Ninject compares.

April 14, 2008 6:57 PM

Torkel Ödegaard said...

I guess it should have been in the test having a slogan like "Lightning-fast dependency injection for .NET"
Hopefully I will have time to do it later in the week, thanks for the tip!

April 14, 2008 7:40 PM

Bil Simser said...

This is interesting but IMHO a bit of a waste of time. I mean, what application would *ever* need to try to create a million objects all at once? Even in a tight loop you *might* create a few thousand objects. I just can't think of any use case where this situation would ever manifest itself so to me the numbers are pretty meaningless. Interesting to look at, but not of any value to judge something by. If the differences were significant with say a few hundred objects then maybe this exercise would be worth something.

April 16, 2008 3:53 PM

Torkel Ödegaard said...

Yes, I agree that this is not a realistic scenario. Doing one million resolves is not something that do in one request. That was just to accumulate the performance difference to see if there were any substantial difference.
I don't think it was a waste of time, because it could have potentially been a big meaningful difference between them. Now it turned out that there weren't but that didn't make the test meaningless, because now you know :)

April 16, 2008 4:25 PM

Nate Kohari said...

Nice post. I'd also be interested to know how Ninject does in comparison. :)
Bil's right, though, that it wouldn't typically make a difference, because most applications don't need to create 1,000,000 instances. However, faster IoC also means that you can use it in places that you wouldn't otherwise be able to -- for example, devices that support the compact framework.
Still a worthwhile study, and it's interesting to see the results!

April 16, 2008 9:43 PM

Ruurd Boeke said...

I'm sorry, but if you are going to do a test and find a huge relative difference, you should not disregard it by looking at the absolute difference. What's the point in doing the test than?
I think it's pretty clear that no container takes a very long time, so what were you hoping to find?
(no disrespect meant, I clicked on the post because I was curious as well ;-) )

April 16, 2008 10:09 PM

Torkel Ödegaard said...

Well the point was to check if there was any relevant difference, not to check which was the fastest.
And I think you can actually disregard a relative difference if that difference is still not relevant when you look at the absolute performance.
My conclusion to the test was that the relative difference was too small to make any relevant difference in real applications.

April 16, 2008 10:41 PM

Anonymous said...

Nice benchmark. A functional comparison for the used Ioc Containers would be interesting. Where do the performance differences come from?

April 17, 2008 9:20 AM

Nick said...

I think the comment about functional differences is important - what are you getting for you time?
In a real app with more components, the factors affecting container performance will shift from the expense of creating instances, to the expense associated with algorithms that are affected by the number of instances (e.g. which instance from many should be returned?) and algorithms that take a time proportional to the size of the dependency graph (e.g. circular dependency checking.)
You can never tell where that performance bottleneck is going to be until you measure it ;)

April 20, 2008 8:09 AM

sharkboy said...

I think what this page shows is that using IOC containers will not make your app significantly slower. What makes apps slow are poor design, bad databases, and network latency.
As to which one to use, you have to try and figure out which one has a future.
I would rule out Spring.Net because it is a Java port and will always be several steps behind in supporting the latest .Net framework features.
StructureMap is cool but since only one guy is supporting it I would expect the project to die once that dude gets tired of dealing with it.
Unity may be the safe bet being that it has "Official" support from Microsoft. The MS guys where starting to promote this at TechEd this year. On the other hand, don't expect any innovation from Microsoft.
If you want a supported component, go with Unity. If you want innovation, go Windsor.

June 16, 2008 6:24 AM

Luke said...

You clearly don't know Jeremy Miller very well if you think that's what'll happen with StructureMap.

July 6, 2008 5:31 PM

本文链接

Functional .NET 4.0 – Tuples and Zip

2011-07-28T13:21:00Z

Previously, when covering some of the additions to the .NET 4.0 Framework such as optional and named parameters, some of the other additions have caught my eye from the perspective of functional programming. Unlike .NET 3.5, this release is not as targeted towards functional programming as it is more towards dynamic programming and COM interoperability. But, there are a few items to note that we can soon take advantage of, including the Tuple type and the Zip operator function among other items.

Looking at Tuples

To define a tuple, it comes from the mathematics field, and is simply an ordered list of values, which are components of that tuple. These components can be of any type, whether it be string, integer, or otherwise. In order to refer to these components, we retrieve references to them by absolute position in that sequence.

In F#, the tuple is a fully supported data type and perhaps one of the most useful. To define a tuple is to define a number of expressions grouped together with comma separation to form a new expression such as the following:

#light

// val blogger : string * string
let blogger1 = "Matthew", "Podwysocki"
let blogger2 = "Jeremy", "Miller"
let blogger3 = "David", "Laribee"

// val bloggers :
// (string * string) * (string * string) * (string * string)
let bloggers = blogger1, blogger2, blogger3

From there, tuples can be decomposed into their components in either of two ways. For pair tuples, a tuple with exactly two components, can be deconstructed using the fst and snd functions such as the following:

#light

let pageHitCount = "http://www.codebetter.com/", 25500
let page = fst pageHitCount
let hitCount = snd pageHitCount

However, it is more common to use a pattern expression to retrieve values from a tuple, such as the following code:

#light

let request =
"http://codebetter",
new DateTime(2008, 11, 15),
"Firefox/3.0.4 (.NET CLR 3.5.30729)"

let host, date, userAgent = request

What we’re able to do is break down the given request into three pieces, the host, date and user-agent. This makes pattern matching against tuples really powerful such as the following:

#light

// val permit_request : string * string * int -> bool
let permit_request = function
| "http", "google.com", 80 -> true
| _, "microsoft.com", _ -> true
| "ftp", _, 21 -> true
| _ -> false

Just as well, we could even use them in active patterns so that we could pattern match against parts of a FileVersionInfo in order to determine which action to take such as the following.

#light

open System.Diagnostics

let (|FileVersionSections|) (f:FileVersionInfo) =
(f.FileName,f.ProductName,f.ProductVersion)
let parse_files = function
| FileVersionSections(fn, "Parallel Extensions for the .NET Framework", _)
-> printfn "Parallel Extensions file %s" fn
| FileVersionSections(fn, "Microsoft Office Communicator 2007", _)
-> printfn "Communicator file %s" fn
| _ -> printfn "Unknown file"

You’re saying, great, but what has this to do with .NET 4.0?

Tuples in .NET 4.0

Earlier this month, Justin Van Patten, on the BCL Team Blog announced some the base class library changes coming to .NET 4.0. Among them was Tuples in which was stated:

We are providing common tuple types in the BCL to facilitate language interoperability and to reduce duplication in the framework. A tuple is a simple generic data structure that holds an ordered set of items of heterogeneous types. Tuples are supported natively in languages such as F# and IronPython, but are also easy to use from any .NET language such as C# and VB.

What does that mean exactly? Does this mean we’ll get some form of syntactic sugar around them as well? If we could decompose them in such a fashion as we do in F#, and to initialize them in an easy fashion without a lot of pomp and circumstance. Gazing from the intent in the .NET libraries, something like this might be an option:

var t1 = Tuple.Create(1, ‘a’);
var i1 = t1.Item1;
var i2 = t1.Item2;

But, unless there were a nicer way to tease apart the data, it just becomes a simple holder of data, instead of something that we could decompose easily into patterns. I would love to some sort of syntactic sugar in C# to allow for this to happen. I am, however, encouraged that they are working with the F# team and other teams to ensure compatibility between the libraries.

If you open Reflector, you will find the type definitions in mscorlib.dll version 4.0 under the System namespace. You may also be surprised to find them as internal classes only at this point, which is unfortunate and we find ourselves not able to take advantage of these things such as the CodeContracts and BigInteger/BigNumber in the .NET 3.5 libraries.

As you can see from the above screen catpure, we have up to 7 arguments for a given tuple and the rest as defined by another tuple. I, however, haven’t seen tuples quite that large before, but it’s always possible…

The Zip Operator Function

Another functional programming item that has been added to the System.Linq.Enumerable class in System.Core.dll. This method allows us to combine two collections together using a function to calculate the new element given the element from each collection.

In F#, we have two ways of doing this in F# in the Seq module. They are defined as:

val map2 : (‘a -> ‘b -> ‘c) -> seq<’a> -> seq<’b> -> seq<’c>
val zip : seq<’a> -> seq<’b> -> seq<’a * ‘b>

The map2 function takes a function which takes the two items from the list to produce the calculated item, and two collections and returns a new collection of the computed items. If one collection is shorter than the other, the rest of the computations are not completed. The zip function is a simple function which takes the items from the first and second collection and combines them in a tuple.

An example of each follows:

// Map2
let l1 = seq[1 .. 26]
let l2 = seq['a' .. 'z']
let mapped = Seq.map2
(fun a b -> sprintf "%d%c" a b) l1 l2

// Zip
let z1 = seq['a' .. 'z']
let z2 = seq['A' .. 'Z']
let zipped = Seq.zip z1 z2

Now, to use the C# version is rather simple. The signature of this method is simply:

public static IEnumerable<TResult> Zip<TFirst, TSecond, TResult>(
this IEnumerable<TFirst> first,
IEnumerable<TSecond> second,
Func<TFirst, TSecond, TResult> func)

As you can see, this follows the same exact pattern as the map2 function from F#, which allows us to compose the two items together via a function to compute the hew item. Let’s define a few tests that will pass given our knowledge of the Zip function. We can also include the Tuple class, well, at least the F# version to show that behavior as well. These are basically tests that I wrote for my Functional C# library, but I hadn’t published my tests, and I probably should.

[Fact]
public void ZipWithAdding_ShouldAddRanges()
{
// Arrange
var range1 = Enumerable.Range(1, 10);
var range2 = Enumerable.Range(11, 10);

// Act
var range3 = range1.Zip(range2, (i, j) => i + j);

// Assert
    Assert.True(range3.Count() == 10);
    Assert.True(range3.ElementAt(0) == 12);
    Assert.True(range3.ElementAt(9) == 30);
}

[Fact]
public void ZipWithIntAndChar_ShouldCombine()
{
// Arrange
var range1 = Enumerable.Range(1, 5);
var range2 = new[] { ‘a’, ‘b’, ‘c’, ‘d’, ‘e’ };

// Act
var range3 = range1.Zip(range2, (i, j) => i + j.ToString());

// Assert
    Assert.True(range3.Count() == 5);
    Assert.True(range3.ElementAt(0) == "1a");
    Assert.True(range3.ElementAt(4) == "5e");
}

[Fact]
public void ZipWithTuples_ShouldCombineLists()
{
// Arrange
var range1 = Enumerable.Range(1, 5);
var range2 = new[] { ‘a’, ‘b’, ‘c’, ‘d’, ‘e’ };

// Act
var range3 = range1.Zip(range2, (i, j) => new Tuple<int, char>(i, j));

// Assert
    Assert.True(range3.Count() == 5);
    Assert.True(range3.ElementAt(0).CompareTo(
new Tuple<int, char>(1, ‘a’)) == 0);
    Assert.True(range3.ElementAt(4).CompareTo(
new Tuple<int, char>(5, ‘e’)) == 0);
}

Because the Parallel Extensions for .NET are becoming part of the BCL in .NET 4.0, the ParallelEnumerable also has the Zip method as well, which allows us to take advantage of data parallelism, should our machine allow such as this:

[Fact]
public void ParallelZipWithAdding_ShouldAddRanges()
{
// Arrange
var range1 = ParallelEnumerable.Range(1, 10);
var range2 = ParallelEnumerable.Range(11, 10);

// Act
var range3 = range1.Zip(range2, (i, j) => i + j);

// Assert
    Assert.True(range3.Count() == 10);
    Assert.True(range3.ElementAt(0) == 12);
    Assert.True(range3.ElementAt(9) == 30);
}

With the including of the Parallel Extensions for .NET, it’s going to be a lot of more functional fun built-into the BCL. I can only hope for more of this coming down the road.

Wrapping It Up

Although the .NET Framework 4.0 release didn’t give too many items for functional programming as they had in the .NET 3.5 release, the .NET 4.0 Framework has a few interesting items with the inclusion of the Tuple and Zip method. Even more intrigue of course comes from adding the Parallel Extensions for the .NET Framework to the base class library as a first-class citizen.

I’d wish they would have made the Tuple class public already so that we could at least play around with some of those features, but I as many understand why some of the decisions were made, and I also realize it’s early in the cycle still. Hopefully in the next release or so, it will become available to us to use, including some syntactic sugar about their creation and decomposition, but ultimately, that’s a language decision and not necessarily a framework decision.

It’s great to see a language convergence in terms of libraries now being available to all. F# will continue to be my language of choice, but with C# gaining some of these libraries, it makes the transition switch much easier without having to reinvent the wheel with either re-implementing the feature or converting Func delegates to F# FastFunc types and back again.

This entry was posted in C#, F#, Functional Programming. Bookmark the permalink. Follow any comments here with the RSS feed for this post.

← .NET Code Contracts and TDD Are Complementary

DC ALT.NET 11/25 – Web Testing Frameworks →

rsenna

Perhaps I got it wrong.

But your C# *Zip* method represents an implementation of F# *map2* function, right? I’m trying to learn F#, so that got me confused.

Anyway, the zip function may be seen as a special case of map2…
http://podwysocki.codebetter.com/ Matthew.Podwysocki

@rsenna

That is correct, the Zip is an implementation of the map2 function.

Matt
http://smellegantcode.wordpress.com/ Daniel Earwicker

Where you wrote:

var range3 = range1.Zip(range2, (i, j) => new Tuple(i, j));

You can actually just put:

var range3 = range1.Zip(range2, Tuple.Create);

This is because there’s a static non-generic helper class with generic overloads of Create (for up to 8 args). Neat!
http://codebetter.com/members/Matthew.Podwysocki/default.aspx Matthew.Podwysocki

@Daniel,

You are correct, but this wasn’t there at the time this post was done.

本文链接

binary search of an integer array

2011-07-28T13:20:00Z

二分法查找

1: // binary search of an integer array, this search is efficient for large arrays 2: // tested with PellesC vegaseat 24jan2005 3: 4: #include <stdio.h> 5: 6: int main() 7: { 8: int a[20] = {0}; 9: int n, i, j, temp; 10: int *beg, *end, *mid, target; 11: 12: printf(" enter the total integers you want to enter (make it less then 20):\n"); 13: scanf("%d", &n); 14: if (n >= 20) return 0; // ouch! 15: printf(" enter the integer array elements:\n" ); 16: for(i = 0; i < n; i++) 17: { 18: scanf("%d", &a[i]); 19: } 20: 21: // sort the loaded array, a must for binary search! 22: // you can apply qsort or other algorithms here 23: for(i = 0; i < n-1; i++) 24: { 25: for(j = 0; j < n-i-1; j++) 26: { 27: if (a[j+1] < a[j]) 28: { 29: temp = a[j]; 30: a[j] = a[j+1]; 31: a[j+1] = temp; 32: } 33: } 34: } 35: printf(" the sorted numbers are:"); 36: for(i = 0; i < n; i++) 37: { 38: printf("%d ", a[i]); 39: } 40: 41: // point to beginning and end of the array 42: beg = &a[0]; 43: end = &a[n]; // use n = one element past the loaded array! 44: printf("\n beg points to address %d and end to %d",beg, end); // test 45: 46: // mid should point somewhere in the middle of these addresses 47: mid = beg += n/2; 48: printf("\n mid points to address %d", mid); // test 49: 50: printf("\n enter the number to be searched:"); 51: scanf("%d",&target); 52: 53: // binary search, there is an AND in the middle of while()!!! 54: while((beg <= end) && (*mid != target)) 55: { 56: // is the target in lower or upper half? 57: if (target < *mid) 58: { 59: end = mid - 1; // new end 60: n = n/2; 61: mid = beg += n/2; // new middle 62: } 63: else 64: { 65: beg = mid + 1; // new beginning 66: n = n/2; 67: mid = beg += n/2; // new middle 68: } 69: } 70: 71: // did you find the target? 72: if (*mid == target) 73: { 74: printf("\n %d found!", target); 75: } 76: else 77: { 78: printf("\n %d not found!", target); 79: } 80: 81: getchar(); // trap enter 82: getchar(); // wait 83: return 0; 84: } 85:

本文链接

JAVA 上加密算法的实现用例

2011-07-28T13:19:00Z

MD5/SHA1，DSA，DESede/DES，Diffie-Hellman 的使用

第 1 章基础知识

1.1. 单钥密码体制

单钥密码体制是一种传统的加密算法，是指信息的发送方和接收方共同使用同一把密钥进行加解密。

通常 , 使用的加密算法比较简便高效 , 密钥简短，加解密速度快，破译极其困难。但是加密的安全性依靠密钥保管的安全性 , 在公开的计算机网络上安全地传送和保管密钥是一个严峻的问题，并且如果在多用户的情况下密钥的保管安全性也是一个问题。

单钥密码体制的代表是美国的 DES

1.2. 消息摘要

一个消息摘要就是一个数据块的数字指纹。即对一个任意长度的一个数据块进行计算，产生一个唯一指印（对于 SHA1 是产生一个 20 字节的二进制数组）。

消息摘要有两个基本属性：

两个不同的报文难以生成相同的摘要
难以对指定的摘要生成一个报文，而由该报文反推算出该指定的摘要

代表：美国国家标准技术研究所的 SHA1 和麻省理工学院 Ronald Rivest 提出的 MD5

1.3. Diffie-Hellman 密钥一致协议

密钥一致协议是由公开密钥密码体制的奠基人 Diffie 和 Hellman 所提出的一种思想。

先决条件 , 允许两名用户在公开媒体上交换信息以生成"一致"的 , 可以共享的密钥

代表：指数密钥一致协议 (Exponential Key Agreement Protocol)

1.4. 非对称算法与公钥体系

1976 年，Dittie 和 Hellman 为解决密钥管理问题，在他们的奠基性的工作"密码学的新方向"一文中，提出一种密钥交换协议，允许在不安全的媒体上通过通讯双方交换信息，安全地传送秘密密钥。在此新思想的基础上，很快出现了非对称密钥密码体制，即公钥密码体制。在公钥体制中，加密密钥不同于解密密钥，加密密钥公之于众，谁都可以使用；解密密钥只有解密人自己知道。它们分别称为公开密钥（Public key）和秘密密钥（Private key）。

迄今为止的所有公钥密码体系中，RSA 系统是最著名、最多使用的一种。RSA 公开密钥密码系统是由 R.Rivest、A.Shamir 和 L.Adleman 俊教授于 1977 年提出的。RSA 的取名就是来自于这三位发明者的姓的第一个字母

1.5. 数字签名

所谓数字签名就是信息发送者用其私钥对从所传报文中提取出的特征数据（或称数字指纹）进行 RSA 算法操作，以保证发信人无法抵赖曾发过该信息（即不可抵赖性），同时也确保信息报文在经签名后末被篡改（即完整性）。当信息接收者收到报文后，就可以用发送者的公钥对数字签名进行验证。　

在数字签名中有重要作用的数字指纹是通过一类特殊的散列函数（HASH 函数）生成的，对这些 HASH 函数的特殊要求是：

接受的输入报文数据没有长度限制；
对任何输入报文数据生成固定长度的摘要（数字指纹）输出
从报文能方便地算出摘要；
难以对指定的摘要生成一个报文，而由该报文反推算出该指定的摘要；
两个不同的报文难以生成相同的摘要

代表：DSA

回页首

第 2 章在 JAVA 中的实现

2.1. 相关

Diffie-Hellman 密钥一致协议和 DES 程序需要 JCE 工具库的支持 , 可以到 http://java.sun.com/security/index.html 下载 JCE, 并进行安装。简易安装把 jce1.2.1\lib 下的所有内容复制到 %java_home%\lib\ext 下 , 如果没有 ext 目录自行建立 , 再把 jce1_2_1.jar 和 sunjce_provider.jar 添加到 CLASSPATH 内 , 更详细说明请看相应用户手册

2.2. 消息摘要 MD5 和 SHA 的使用

使用方法 :

首先用生成一个 MessageDigest 类 , 确定计算方法

java.security.MessageDigest alga=java.security.MessageDigest.getInstance("SHA-1");

添加要进行计算摘要的信息

alga.update(myinfo.getBytes());

计算出摘要

byte[] digesta=alga.digest();

发送给其他人你的信息和摘要

其他人用相同的方法初始化 , 添加信息 , 最后进行比较摘要是否相同

algb.isEqual(digesta,algb.digest())

Exploring The Major Interfaces in Rx

2011-07-08T06:09:00Z

本文描述了主要的Reactive Extensions (Rx)接口，其用于表示observable序列，并subscribe它们。

IObservable<T>/IObserver<T>在.NET 4.0基础类库中出现，它们也可作为.NET 3.5, Silverlight 3 and 4以及Javascript的一个包安装。

IObservable<T>/IObserver<T>

Rx exposes asynchronous and event-based data sources as push-based, observable sequences abstracted by the new IObservable<T> interface in .NET Framework 4.0. This IObservable<T> interface is a dual of the familiar IEnumerable<T> interface used for pull-based, enumerable collections. It represents a data source that can be observed, meaning that it can send data to anyone who is interested. It maintains a list of dependent IObserver<T> implementations representing such interested listeners, and notifies them automatically of any state changes.

Rx公开异步和基于事件的数据源，作为push模式的基础，observable序列由.NET Framework 4.0中的IObservable<T>接口抽象。IObservable<T>接口非常类似于IEnumerable<T>接口，只是IEnumerable<T>接口用于pull-based，可枚举集合。IObservable<T>接口代表可被观察的数据源——即它可以发送数据给任何关注他的对象。它维护了一个依赖于IObserver<T>实现的对象的列表，诸如那些关注数据源的listeners，并自动通知它们任何状态更改。

An implementation of the IObservable<T> interface can be viewed as a collection of elements of type T. Therefore, an IObservable<int> can be viewed as a collection of integers, in which integers will be pushed to the subscribed observers.

IObservable<T>接口的实现可呈现为元素T的一个集合。因此，IObservable<int>可以视为整数集合，在它里面，整数将被push给每个订阅的observers。

As described in What is Rx, the other half of the push model is represented by the IObserver<T> interface, which represents an observer who registers an interest through a subscription. Items are subsequently handed to the observer from the observable sequence to which it subscribes.

如What is Rx所述，push模式的另一半由IObserver<T>接口表示，它代表一个observer，其通过subscription注册关注点（interest）。项随后从observable序列被移交给订阅了它的observer。

In order to receive notifications from an observable collection, you use the Subscribe method of IObservable to hand it an IObserver<T> object. In return for this observer, the Subscribe method returns an IDisposable object that acts as a handle for the subscription. This allows you to clean up the subscription after you are done. Calling Dispose on this object detaches the observer from the source so that notifications are no longer delivered. As you can infer, in Rx you do not need to explicitly unsubscribe from an event as in the .NET event model.

为了从observable集合接收到通知，需使用IObservable 接口的Subscribe方法，以将IObservable移交给IObserver<T>对象。此observer的返回中，Subscribe方法返回了一个IDisposable对象，它代表这个subscription的handle。这允许你完成处理后清除subscription。调用此对象上的Dispose方法将分离此observer与源，这样，通知将不再传输给它。如你所推断，在Rx中，你无须像在.NET 事件模型中那样显式的unsubscribe event。

Observers support three publication events, reflected by the interface’s methods. OnNext can be called zero or more times, when the observable data source has data available. For example, an observable data source used for mouse move events can send out a Point object every time the mouse has moved. The other two methods are used to indicate completion or errors.

Observers支持3个公开的事件，都由接口的方法所反映。OnNext可以被调用0次或多次，当observable数据源具有有效数据时。例如，用于mouse move事件的observable数据源可以在每次mouse移动时发送一个Point对象。另2个方法用于指示完成或错误状态。

The following lists the IObservable<T>/IObserver<T> interfaces.

下面是IObservable<T>/IObserver<T>接口定义。public interface IObservable<out T>

{

IDisposable Subscribe(IObserver<T> observer);

}

public interface IObserver<in T>

{

void OnCompleted(); // Notifies the observer that the source has finished sending messages.

void OnError(Exception error); // Notifies the observer about any exception or error.

void OnNext(T value); // Pushes the next data value from the source to the observer.

}

Rx also provides Subscribe extension methods so that you can avoid implementing the IObserver<T> interface yourself. For each publication event (OnNext, OnError, OnCompleted) of an observable sequence, you can specify a delegate that will be invoked, as shown in the following example. If you do not specify an action for an event, the default behavior will occur.

Rx也提供了Subscribe扩展方法，因此你可以避免自己去实现IObserver<T>接口。对于observable序列的每个公开事件（OnNext, OnError, OnCompleted），你可以指定一个委托，其再合适的时候被调用，如下例所示。如果你没有为事件指定一个action，默认的行为将发生。IObservable<int> source = Observable.Range(1, 5); //creates an observable sequence of 5 integers, starting from 1

IDisposable subscription = source.Subscribe(

x => Console.WriteLine("OnNext: {0}", x), //prints out the value being pushed

ex => Console.WriteLine("OnError: {0}", ex.Message),

() => Console.WriteLine("OnCompleted"));

You can treat the observable sequence (such as a sequence of mouse-over events) as if it were a normal collection. Thus you can write LINQ queries over the collection to do things like filtering, grouping, composing, etc. To make observable sequences more useful, the Rx assemblies provide many factory LINQ operators so that you do not need to implement any of these on your own. This will be covered in the Querying Observable Sequences using LINQ Operators topic.

你可以像普通集合那样对待observable sequence（如：mouse over事件序列）。因此你可以在这个集合上编写编写LINQ查询，执行诸如过滤，分组，组合等等。为了使observable sequences更有用，Rx程序集提供了很多工厂LINQ操作，请参考Querying Observable Sequences using LINQ Operators。

Caution:

You do not need to implement the IObservable<T>/IObserver<T> interfaces yourself. Rx provides internal implementations of these interfaces for you and exposes them through various extension methods provided by the Observable and Observer types. See the Creating and Querying Observable Sequences topic for more information.

注意：你无须自行实现IObservable<T>/IObserver<T>接口。Rx提供了这些接口的internal实现，并通过Observable and Observer类型的各种扩展方法公开它们，参考Creating and Querying Observable Sequences。

本文链接