博客园_华志昊

XPath Subquery

2012-01-10T09:05:00Z

XmlDocument doc = new XmlDocument();
            doc.LoadXml(@"<?xml version='1.0' encoding='utf-8' ?>
                <root>
                  <foo>
                    <table>
                      <tr>
                        <td>
                          <div>
                            <div>
                              a
                              <div>abc</div>b
                            </div>
                          </div>
                        </td>
                      </tr>
                      <tr>
                        <td class='abc'>b</td>
                      </tr>
                      <tr>
                        <td>a</td>
                      </tr>
                    </table>
                  </foo>
                </root>");
            XmlNodeList nodes = doc.SelectNodes(@"//table/tr[*[contains(string(),'abc')]]");//
            for (int i = 0; i < nodes.Count; i++)
            {
                XmlElement ele = nodes[i] as XmlElement;
            }
            Console.WriteLine(nodes.Count);

本文链接

PowerCollections学习笔记(2):继承和模式

2011-10-20T03:26:00Z

继承

Abstract	CollectionBase<T>
Implement	Bag<T>	OrderedBag<T>	OrderedSet<T>
Feature	duplicated	ordered	ordered & non-duplicated

Abstract	ListBase<T>
Implement	Deque<T>	BigList<T>
Feature	optimized for inserting at beginning	optimized for >100

Abstract	DictionaryBase<TKey, TValue>
Implement	OrderedDictionary<TKey, TValue>
Feature	ordered

Abstract	MultiDictionaryBase<TKey, TValue>
Implement	MultiDictionary<TKey, TValue>
Feature	multiple values associated with one key

模式

Pair<TFirst, TSecond>	as Type of	CollectionBase<T>
Triple<TFirst, TSecond, TThird>	as Type of	DictionaryBase<TKey, TValue>

CollectionBase<T>	readonly	ReadOnlyCollectionBase<T>
ListBase<T>		ReadOnlyListBase<T>
DictionaryBase<TKey, TValue>		ReadOnlyDictionaryBase<TKey, TValue>
MultiDictionaryBase<TKey, TValue>		ReadOnlyMultiDictionaryBase<TKey, TValue>

OrderedSet<T>	subclass	OrderedSet<T>.View : CollectionBase<T>
OrderedBag<T>		OrderedBag<T>.View : CollectionBase<T>
OrderedDictionary<TKey, TValue>		OrderedDictionary<TKey, TValue>.View : DictionaryBase<TKey, TValue>
OrderedMultiDictionary<TKey, TValue>		OrderedMultiDictionary<TKey, TValue>.View : MultiDictionaryBase<TKey, TValue>

本文链接

PowerCollections学习笔记(1):术语解释

2011-10-20T02:38:00Z

public class Bag<T> : CollectionBase<T>, ICloneable
//Bag<T> is a collection that contains items of type T. Unlike a Set, duplicate items (items that compare equal to each other) are allowed in an Bag.

public class BigList<T> : ListBase<T>, ICloneable
//BigList<T> provides a list of items, in order, with indices of the items ranging from 0 to one less than the count of items in the collection. BigList<T> is optimized for efficient operations on large (>100 items) lists, especially for insertions, deletions, copies, and concatinations.

public abstract class CollectionBase<T> : ICollection<T>,
    IEnumerable<T>, ICollection, IEnumerable
//CollectionBase is a base class that can be used to more easily implement the generic ICollection<T> and non-generic ICollection interfaces.

public class Deque<T> : ListBase<T>, ICloneable
//The Deque class implements a type of list known as a Double Ended Queue. A Deque is quite similar to a List, in that items have indices (starting at 0), and the item at any index can be efficiently retrieved. The difference between a List and a Deque lies in the efficiency of inserting elements at the beginning. In a List, items can be efficiently added to the end, but inserting an item at the beginning of the List is slow, taking time proportional to the size of the List. In a Deque, items can be added to the beginning or end equally efficiently, regardless of the number of items in the Deque. As a trade-off for this increased flexibility, Deque is somewhat slower than List (but still constant time) when being indexed to get or retrieve elements.

public abstract class DictionaryBase<TKey, TValue> : CollectionBase<KeyValuePair<TKey, TValue>>, IDictionary<TKey, TValue>,
    ICollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>>,
    IDictionary, ICollection, IEnumerable
//DictionaryBase is a base class that can be used to more easily implement the generic IDictionary<T> and non-generic IDictionary interfaces.

public abstract class ListBase<T> : CollectionBase<T>, IList<T>,
    ICollection<T>, IEnumerable<T>, IList, ICollection, IEnumerable
//ListBase is an abstract class that can be used as a base class for a read-write collection that needs to implement the generic IList<T> and non-generic IList collections. The derived class needs to override the following methods: Count, Clear, Insert, RemoveAt, and the indexer. The implementation of all the other methods in IList<T> and IList are handled by ListBase.

public class MultiDictionary<TKey, TValue> : MultiDictionaryBase<TKey, TValue>, ICloneable
//The MultiDictionary class that associates values with a key. Unlike an Dictionary, each key can have multiple values associated with it. When indexing an MultiDictionary, instead of a single value associated with a key, you retrieve an enumeration of values.

public abstract class MultiDictionaryBase<TKey, TValue> : CollectionBase<KeyValuePair<TKey, ICollection<TValue>>>, IDictionary<TKey, ICollection<TValue>>,
    ICollection<KeyValuePair<TKey, ICollection<TValue>>>, IEnumerable<KeyValuePair<TKey, ICollection<TValue>>>,
    IEnumerable
//MultiDictionaryBase is a base class that can be used to more easily implement a class that associates multiple values to a single key. The class implements the generic IDictionary<TKey, ICollection<TValue>> interface.

public class OrderedBag<T> : CollectionBase<T>, ICloneable
//OrderedBag<T> is a collection that contains items of type T. The item are maintained in a sorted order. Unlike a OrderedSet, duplicate items (items that compare equal to each other) are allows in an OrderedBag.

public class View : CollectionBase<T>
//The OrderedBag<T>.View class is used to look at a subset of the items inside an ordered bag. It is returned from the Range, RangeTo, RangeFrom, and Reversed methods.

public class OrderedDictionary<TKey, TValue> : DictionaryBase<TKey, TValue>, ICloneable
//OrderedDictionary<TKey, TValue> is a collection that maps keys of type TKey to values of type TValue. The keys are maintained in a sorted order, and at most one value is permitted for each key.

public class View : DictionaryBase<TKey, TValue>
//The OrderedDictionary<TKey,TValue>.View class is used to look at a subset of the keys and values inside an ordered dictionary. It is returned from the Range, RangeTo, RangeFrom, and Reversed methods.

public class OrderedMultiDictionary<TKey, TValue> : MultiDictionaryBase<TKey, TValue>, ICloneable
//The OrderedMultiDictionary class that associates values with a key. Unlike an OrderedDictionary, each key can have multiple values associated with it. When indexing an OrderedMultidictionary, instead of a single value associated with a key, you retrieve an enumeration of values.

//All of the key are stored in sorted order. Also, the values associated with a given key are kept in sorted order as well.

//When constructed, you can chose to allow the same value to be associated with a key multiple times, or only one time.

public class View : MultiDictionaryBase<TKey, TValue>
//The OrderedMultiDictionary<TKey,TValue>.View class is used to look at a subset of the keys and values inside an ordered multi-dictionary. It is returned from the Range, RangeTo, RangeFrom, and Reversed methods.

public class OrderedSet<T> : CollectionBase<T>, ICollection<T>,
    IEnumerable<T>, IEnumerable, ICloneable
//OrderedSet<T> is a collection that contains items of type T. The item are maintained in a sorted order, and duplicate items are not allowed. Each item has an index in the set: the smallest item has index 0, the next smallest item has index 1, and so forth.

public class View : CollectionBase<T>, ICollection<T>,
    IEnumerable<T>, IEnumerable

//The OrderedSet<T>.View class is used to look at a subset of the Items inside an ordered set. It is returned from the Range, RangeTo, RangeFrom, and Reversed methods.

public struct Pair<TFirst, TSecond> : IComparable,
    IComparable<Pair<TFirst, TSecond>>
//Stores a pair of objects within a single struct. This struct is useful to use as the T of a collection, or as the TKey or TValue of a dictionary.

public abstract class ReadOnlyCollectionBase<T> : ICollection<T>,
    IEnumerable<T>, ICollection, IEnumerable
//ReadOnlyCollectionBase is a base class that can be used to more easily implement the generic ICollection<T> and non-generic ICollection interfaces for a read-only collection: a collection that does not allow adding or removing elements.

public abstract class ReadOnlyDictionaryBase<TKey, TValue> : ReadOnlyCollectionBase<KeyValuePair<TKey, TValue>>, IDictionary<TKey, TValue>,
    ICollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>>,
    IDictionary, ICollection, IEnumerable
//ReadOnlyDictionaryBase is a base class that can be used to more easily implement the generic IDictionary<T> and non-generic IDictionary interfaces.

public abstract class ReadOnlyListBase<T> : ReadOnlyCollectionBase<T>, IList<T>,
    ICollection<T>, IEnumerable<T>, IList, ICollection, IEnumerable
//ReadOnlyListBase is an abstract class that can be used as a base class for a read-only collection that needs to implement the generic IList<T> and non-generic IList collections. The derived class needs to override the Count property and the get part of the indexer. The implementation of all the other methods in IList<T> and IList are handled by ListBase.

public abstract class ReadOnlyMultiDictionaryBase<TKey, TValue> : ReadOnlyCollectionBase<KeyValuePair<TKey, ICollection<TValue>>>, IDictionary<TKey, ICollection<TValue>>,
    ICollection<KeyValuePair<TKey, ICollection<TValue>>>, IEnumerable<KeyValuePair<TKey, ICollection<TValue>>>,
    IEnumerable
//MultiDictionaryBase is a base class that can be used to more easily implement a class that associates multiple values to a single key. The class implements the generic IDictionary<TKey, ICollection<TValue>> interface. The resulting collection is read-only -- items cannot be added or removed.

public class Set<T> : CollectionBase<T>, ICollection<T>,
    IEnumerable<T>, IEnumerable, ICloneable
//Set<T> is a collection that contains items of type T. The item are maintained in a haphazard, unpredictable order, and duplicate items are not allowed.

public struct Triple<TFirst, TSecond, TThird> : IComparable,
    IComparable<Triple<TFirst, TSecond, TThird>>
//Stores a triple of objects within a single struct. This struct is useful to use as the T of a collection, or as the TKey or TValue of a dictionary.

public static class Algorithms
{
    public static int BinarySearch<T>(IList<T> list, T item, out int index) where T : IComparable<T>;
    public static int BinarySearch<T>(IList<T> list, T item, Comparison<T> comparison, out int index);
    public static int BinarySearch<T>(IList<T> list, T item, IComparer<T> comparer, out int index);
    public static IEnumerable<Pair<TFirst, TSecond>> CartesianProduct<TFirst, TSecond>(IEnumerable<TFirst> first, IEnumerable<TSecond> second);
    public static IEnumerable<T> Concatenate<T>(params IEnumerable<T>[] collections);
    public static IEnumerable<TDest> Convert<TSource, TDest>(IEnumerable<TSource> sourceCollection, Converter<TSource, TDest> converter);
    public static void Copy<T>(IEnumerable<T> source, IList<T> dest, int destIndex);
    public static void Copy<T>(IEnumerable<T> source, T[] dest, int destIndex);
    public static void Copy<T>(IEnumerable<T> source, IList<T> dest, int destIndex, int count);
    public static void Copy<T>(IEnumerable<T> source, T[] dest, int destIndex, int count);
    public static void Copy<T>(IList<T> source, int sourceIndex, IList<T> dest, int destIndex, int count);
    public static void Copy<T>(IList<T> source, int sourceIndex, T[] dest, int destIndex, int count);
    public static int Count<T>(IEnumerable<T> collection);
    public static int CountEqual<T>(IEnumerable<T> collection, T find);
    public static int CountEqual<T>(IEnumerable<T> collection, T find, IEqualityComparer<T> equalityComparer);
    public static int CountWhere<T>(IEnumerable<T> collection, Predicate<T> predicate);
    public static bool DisjointSets<T>(IEnumerable<T> collection1, IEnumerable<T> collection2);
    public static bool DisjointSets<T>(IEnumerable<T> collection1, IEnumerable<T> collection2, IEqualityComparer<T> equalityComparer);
    public static bool EqualCollections<T>(IEnumerable<T> collection1, IEnumerable<T> collection2);
    public static bool EqualCollections<T>(IEnumerable<T> collection1, IEnumerable<T> collection2, BinaryPredicate<T> predicate);
    public static bool EqualCollections<T>(IEnumerable<T> collection1, IEnumerable<T> collection2, IEqualityComparer<T> equalityComparer);
    public static bool EqualSets<T>(IEnumerable<T> collection1, IEnumerable<T> collection2);
    public static bool EqualSets<T>(IEnumerable<T> collection1, IEnumerable<T> collection2, IEqualityComparer<T> equalityComparer);
    public static bool Exists<T>(IEnumerable<T> collection, Predicate<T> predicate);
    public static void Fill<T>(IList<T> list, T value);
    public static void Fill<T>(T[] array, T value);
    public static void FillRange<T>(IList<T> list, int start, int count, T value);
    public static void FillRange<T>(T[] array, int start, int count, T value);
    public static int FindFirstIndexWhere<T>(IList<T> list, Predicate<T> predicate);
    public static T FindFirstWhere<T>(IEnumerable<T> collection, Predicate<T> predicate);
    public static IEnumerable<int> FindIndicesWhere<T>(IList<T> list, Predicate<T> predicate);
    public static int FindLastIndexWhere<T>(IList<T> list, Predicate<T> predicate);
    public static T FindLastWhere<T>(IEnumerable<T> collection, Predicate<T> predicate);
    public static IEnumerable<T> FindWhere<T>(IEnumerable<T> collection, Predicate<T> predicate);
    public static int FirstConsecutiveEqual<T>(IList<T> list, int count);
    public static int FirstConsecutiveEqual<T>(IList<T> list, int count, BinaryPredicate<T> predicate);
    public static int FirstConsecutiveEqual<T>(IList<T> list, int count, IEqualityComparer<T> equalityComparer);
    public static int FirstConsecutiveWhere<T>(IList<T> list, int count, Predicate<T> predicate);
    public static int FirstIndexOf<T>(IList<T> list, T item);
    public static int FirstIndexOf<T>(IList<T> list, T item, IEqualityComparer<T> equalityComparer);
    public static int FirstIndexOfMany<T>(IList<T> list, IEnumerable<T> itemsToLookFor);
    public static int FirstIndexOfMany<T>(IList<T> list, IEnumerable<T> itemsToLookFor, BinaryPredicate<T> predicate);
    public static int FirstIndexOfMany<T>(IList<T> list, IEnumerable<T> itemsToLookFor, IEqualityComparer<T> equalityComparer);
    public static void ForEach<T>(IEnumerable<T> collection, Action<T> action);
    public static IEnumerable<T[]> GeneratePermutations<T>(IEnumerable<T> collection);
    public static IEnumerable<T[]> GenerateSortedPermutations<T>(IEnumerable<T> collection) where T : IComparable<T>;
    public static IEnumerable<T[]> GenerateSortedPermutations<T>(IEnumerable<T> collection, Comparison<T> comparison);
    public static IEnumerable<T[]> GenerateSortedPermutations<T>(IEnumerable<T> collection, IComparer<T> comparer);
    public static IEqualityComparer<IEnumerable<T>> GetCollectionEqualityComparer<T>();
    public static IEqualityComparer<IEnumerable<T>> GetCollectionEqualityComparer<T>(IEqualityComparer<T> equalityComparer);
    public static IComparer<T> GetComparerFromComparison<T>(Comparison<T> comparison);
    public static Comparison<T> GetComparisonFromComparer<T>(IComparer<T> comparer);
    public static Converter<TKey, TValue> GetDictionaryConverter<TKey, TValue>(IDictionary<TKey, TValue> dictionary);
    public static Converter<TKey, TValue> GetDictionaryConverter<TKey, TValue>(IDictionary<TKey, TValue> dictionary, TValue defaultValue);
    public static IEqualityComparer<T> GetIdentityComparer<T>() where T : class;
    public static IComparer<IEnumerable<T>> GetLexicographicalComparer<T>() where T : IComparable<T>;
    public static IComparer<IEnumerable<T>> GetLexicographicalComparer<T>(Comparison<T> comparison);
    public static IComparer<IEnumerable<T>> GetLexicographicalComparer<T>(IComparer<T> comparer);
    public static IComparer<T> GetReverseComparer<T>(IComparer<T> comparer);
    public static Comparison<T> GetReverseComparison<T>(Comparison<T> comparison);
    public static IEqualityComparer<IEnumerable<T>> GetSetEqualityComparer<T>();
    public static IEqualityComparer<IEnumerable<T>> GetSetEqualityComparer<T>(IEqualityComparer<T> equalityComparer);
    public static int IndexOfMaximum<T>(IList<T> list) where T : IComparable<T>;
    public static int IndexOfMaximum<T>(IList<T> list, Comparison<T> comparison);
    public static int IndexOfMaximum<T>(IList<T> list, IComparer<T> comparer);
    public static int IndexOfMinimum<T>(IList<T> list) where T : IComparable<T>;
    public static int IndexOfMinimum<T>(IList<T> list, Comparison<T> comparison);
    public static int IndexOfMinimum<T>(IList<T> list, IComparer<T> comparer);
    public static IEnumerable<int> IndicesOf<T>(IList<T> list, T item);
    public static IEnumerable<int> IndicesOf<T>(IList<T> list, T item, IEqualityComparer<T> equalityComparer);
    public static IEnumerable<int> IndicesOfMany<T>(IList<T> list, IEnumerable<T> itemsToLookFor);
    public static IEnumerable<int> IndicesOfMany<T>(IList<T> list, IEnumerable<T> itemsToLookFor, BinaryPredicate<T> predicate);
    public static IEnumerable<int> IndicesOfMany<T>(IList<T> list, IEnumerable<T> itemsToLookFor, IEqualityComparer<T> equalityComparer);
    public static bool IsProperSubsetOf<T>(IEnumerable<T> collection1, IEnumerable<T> collection2);
    public static bool IsProperSubsetOf<T>(IEnumerable<T> collection1, IEnumerable<T> collection2, IEqualityComparer<T> equalityComparer);
    public static bool IsSubsetOf<T>(IEnumerable<T> collection1, IEnumerable<T> collection2);
    public static bool IsSubsetOf<T>(IEnumerable<T> collection1, IEnumerable<T> collection2, IEqualityComparer<T> equalityComparer);
    public static int LastIndexOf<T>(IList<T> list, T item);
    public static int LastIndexOf<T>(IList<T> list, T item, IEqualityComparer<T> equalityComparer);
    public static int LastIndexOfMany<T>(IList<T> list, IEnumerable<T> itemsToLookFor);
    public static int LastIndexOfMany<T>(IList<T> list, IEnumerable<T> itemsToLookFor, BinaryPredicate<T> predicate);
    public static int LastIndexOfMany<T>(IList<T> list, IEnumerable<T> itemsToLookFor, IEqualityComparer<T> equalityComparer);
    public static int LexicographicalCompare<T>(IEnumerable<T> sequence1, IEnumerable<T> sequence2) where T : IComparable<T>;
    public static int LexicographicalCompare<T>(IEnumerable<T> sequence1, IEnumerable<T> sequence2, Comparison<T> comparison);
    public static int LexicographicalCompare<T>(IEnumerable<T> sequence1, IEnumerable<T> sequence2, IComparer<T> comparer);
    public static T Maximum<T>(IEnumerable<T> collection) where T : IComparable<T>;
    public static T Maximum<T>(IEnumerable<T> collection, Comparison<T> comparison);
    public static T Maximum<T>(IEnumerable<T> collection, IComparer<T> comparer);
    public static IEnumerable<T> MergeSorted<T>(params IEnumerable<T>[] collections) where T : IComparable<T>;
    public static IEnumerable<T> MergeSorted<T>(Comparison<T> comparison, params IEnumerable<T>[] collections);
    public static IEnumerable<T> MergeSorted<T>(IComparer<T> comparer, params IEnumerable<T>[] collections);
    public static T Minimum<T>(IEnumerable<T> collection) where T : IComparable<T>;
    public static T Minimum<T>(IEnumerable<T> collection, Comparison<T> comparison);
    public static T Minimum<T>(IEnumerable<T> collection, IComparer<T> comparer);
    public static IEnumerable<T> NCopiesOf<T>(int n, T item);
    public static int Partition<T>(IList<T> list, Predicate<T> predicate);
    public static T[] RandomShuffle<T>(IEnumerable<T> collection);
    public static T[] RandomShuffle<T>(IEnumerable<T> collection, Random randomGenerator);
    public static void RandomShuffleInPlace<T>(IList<T> list);
    public static void RandomShuffleInPlace<T>(IList<T> list, Random randomGenerator);
    public static T[] RandomSubset<T>(IEnumerable<T> collection, int count);
    public static T[] RandomSubset<T>(IEnumerable<T> collection, int count, Random randomGenerator);
    public static IList<T> Range<T>(IList<T> list, int start, int count);
    public static IList<T> Range<T>(T[] array, int start, int count);
    public static ICollection<T> ReadOnly<T>(ICollection<T> collection);
    public static IDictionary<TKey, TValue> ReadOnly<TKey, TValue>(IDictionary<TKey, TValue> dictionary);
    public static IList<T> ReadOnly<T>(IList<T> list);
    public static IList<T> ReadWriteList<T>(T[] array);
    public static IEnumerable<T> RemoveDuplicates<T>(IEnumerable<T> collection);
    public static IEnumerable<T> RemoveDuplicates<T>(IEnumerable<T> collection, BinaryPredicate<T> predicate);
    public static IEnumerable<T> RemoveDuplicates<T>(IEnumerable<T> collection, IEqualityComparer<T> equalityComparer);
    public static void RemoveDuplicatesInPlace<T>(IList<T> list);
    public static void RemoveDuplicatesInPlace<T>(IList<T> list, BinaryPredicate<T> predicate);
    public static void RemoveDuplicatesInPlace<T>(IList<T> list, IEqualityComparer<T> equalityComparer);
    public static ICollection<T> RemoveWhere<T>(ICollection<T> collection, Predicate<T> predicate);
    public static IEnumerable<T> Replace<T>(IEnumerable<T> collection, Predicate<T> predicate, T replaceWith);
    public static IEnumerable<T> Replace<T>(IEnumerable<T> collection, T itemFind, T replaceWith);
    public static IEnumerable<T> Replace<T>(IEnumerable<T> collection, T itemFind, T replaceWith, IEqualityComparer<T> equalityComparer);
    public static void ReplaceInPlace<T>(IList<T> list, Predicate<T> predicate, T replaceWith);
    public static void ReplaceInPlace<T>(IList<T> list, T itemFind, T replaceWith);
    public static void ReplaceInPlace<T>(IList<T> list, T itemFind, T replaceWith, IEqualityComparer<T> equalityComparer);
    public static IEnumerable<T> Reverse<T>(IList<T> source);
    public static void ReverseInPlace<T>(IList<T> list);
    public static IEnumerable<T> Rotate<T>(IList<T> source, int amountToRotate);
    public static void RotateInPlace<T>(IList<T> list, int amountToRotate);
    public static int SearchForSubsequence<T>(IList<T> list, IEnumerable<T> pattern);
    public static int SearchForSubsequence<T>(IList<T> list, IEnumerable<T> pattern, BinaryPredicate<T> predicate);
    public static int SearchForSubsequence<T>(IList<T> list, IEnumerable<T> pattern, IEqualityComparer<T> equalityComparer);
    public static IEnumerable<T> SetDifference<T>(IEnumerable<T> collection1, IEnumerable<T> collection2);
    public static IEnumerable<T> SetDifference<T>(IEnumerable<T> collection1, IEnumerable<T> collection2, IEqualityComparer<T> equalityComparer);
    public static IEnumerable<T> SetIntersection<T>(IEnumerable<T> collection1, IEnumerable<T> collection2);
    public static IEnumerable<T> SetIntersection<T>(IEnumerable<T> collection1, IEnumerable<T> collection2, IEqualityComparer<T> equalityComparer);
    public static IEnumerable<T> SetSymmetricDifference<T>(IEnumerable<T> collection1, IEnumerable<T> collection2);
    public static IEnumerable<T> SetSymmetricDifference<T>(IEnumerable<T> collection1, IEnumerable<T> collection2, IEqualityComparer<T> equalityComparer);
    public static IEnumerable<T> SetUnion<T>(IEnumerable<T> collection1, IEnumerable<T> collection2);
    public static IEnumerable<T> SetUnion<T>(IEnumerable<T> collection1, IEnumerable<T> collection2, IEqualityComparer<T> equalityComparer);
    public static T[] Sort<T>(IEnumerable<T> collection) where T : IComparable<T>;
    public static T[] Sort<T>(IEnumerable<T> collection, Comparison<T> comparison);
    public static T[] Sort<T>(IEnumerable<T> collection, IComparer<T> comparer);
    public static void SortInPlace<T>(IList<T> list) where T : IComparable<T>;
    public static void SortInPlace<T>(IList<T> list, Comparison<T> comparison);
    public static void SortInPlace<T>(IList<T> list, IComparer<T> comparer);
    public static int StablePartition<T>(IList<T> list, Predicate<T> predicate);
    public static T[] StableSort<T>(IEnumerable<T> collection) where T : IComparable<T>;
    public static T[] StableSort<T>(IEnumerable<T> collection, Comparison<T> comparison);
    public static T[] StableSort<T>(IEnumerable<T> collection, IComparer<T> comparer);
    public static void StableSortInPlace<T>(IList<T> list) where T : IComparable<T>;
    public static void StableSortInPlace<T>(IList<T> list, Comparison<T> comparison);
    public static void StableSortInPlace<T>(IList<T> list, IComparer<T> comparer);
    public static T[] ToArray<T>(IEnumerable<T> collection);
    public static string ToString<TKey, TValue>(IDictionary<TKey, TValue> dictionary);
    public static string ToString<T>(IEnumerable<T> collection);
    public static string ToString<T>(IEnumerable<T> collection, bool recursive, string start, string separator, string end);
    public static bool TrueForAll<T>(IEnumerable<T> collection, Predicate<T> predicate);
    public static bool TryFindFirstWhere<T>(IEnumerable<T> collection, Predicate<T> predicate, out T foundItem);
    public static bool TryFindLastWhere<T>(IEnumerable<T> collection, Predicate<T> predicate, out T foundItem);
    public static ICollection<T> TypedAs<T>(ICollection untypedCollection);
    public static IEnumerable<T> TypedAs<T>(IEnumerable untypedCollection);
    public static IList<T> TypedAs<T>(IList untypedList);
    public static ICollection Untyped<T>(ICollection<T> typedCollection);
    public static IList Untyped<T>(IList<T> typedList);
}

本文链接

Listen(int backlog)的意义

2011-10-14T02:15:00Z

理想情况是:

using System;
using System.Collections.Generic;
using System.Threading;
using System.Text;
using System.Diagnostics;
using System.Net;
using System.IO;
using System.Net.Sockets;

namespace HTTPProxyServer
{
    class Program
    {
        static void Main(string[] args)
        {
            Server.Start(10);
            IPHostEntry IpEntry = Dns.GetHostEntry(Dns.GetHostName());
            for (int i = 0; i < 20; i++)
            {
                Socket client = new Socket(AddressFamily.InterNetwork,
                    SocketType.Stream, ProtocolType.Tcp);
                client.Connect(new IPEndPoint(IpEntry.AddressList[0], 8080));
                Console.WriteLine(i + ":" + client.Connected);
            }
        }
    }

}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Net.Sockets;
using System.Net;
using System.IO;
using System.Threading;

namespace HTTPProxyServer
{
    class Server
    {
        private Socket listener = null;

        public readonly static Server instance;

        static Server()
        {
            instance = new Server();
            instance.listener = new Socket(AddressFamily.InterNetwork,
                SocketType.Stream, ProtocolType.Tcp);
        }

        public static void Start(int number)
        {
            Thread thread = new Thread(new ParameterizedThreadStart((object backlog) =>
            {
                IPHostEntry IpEntry = Dns.GetHostEntry(Dns.GetHostName());
                for (int i = 0; i < IpEntry.AddressList.Length; i++)
                {

                    instance.listener.Bind(new IPEndPoint(IpEntry.AddressList[i], 8080));
                    Console.WriteLine("bind : " + IpEntry.AddressList[i].AddressFamily);
                }
                instance.listener.Listen((int)backlog);
                try
                {
                    while (true)
                    {

                        instance.listener.BeginAccept(
                            new AsyncCallback(AcceptCallback),
                            instance.listener);

                    }

                }
                catch (Exception e)
                {
                    Console.WriteLine(e.ToString());
                }
            }));
            thread.Start(number);
        }

        public static void AcceptCallback(IAsyncResult ar)
        {

            Socket listener = (Socket)ar.AsyncState;
            Socket handler = listener.EndAccept(ar);

            Console.WriteLine("conneceted : " + handler.RemoteEndPoint.ToString());
            //todo
            //handler.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0,
            //    new AsyncCallback(ReadCallback), state);
        }

    }

}

本文链接

SQL中布尔表达式的非二项性

2011-08-03T09:32:00Z

通常大部分语言中"布尔表达式"的值不是True就是False。然而也有个把例外，比如SQL中，你可以尝试运行以下两行代码，

select 1 where 1 not in (null)

select 1 where 1 in (null)

有意思的是它们都返回0行结果。

本文链接

dm_exec_query_stats 几点心得

2011-07-13T07:41:00Z

dm_exec_query_stats是MS SQL Server2005新提供的系统函数，初次使用发现功能非常全面。可以提供一些特殊的解决问题的思路。

1 SELECT qs.execution_count,
2     SUBSTRING(qt.text,qs.statement_start_offset/2 +1,
3                  (CASE WHEN qs.statement_end_offset = -1
4                        THEN LEN(CONVERT(nvarchar(max), qt.text)) * 2
5                        ELSE qs.statement_end_offset end -
6                             qs.statement_start_offset
7                  )/2
8              ) AS query_text,
9      qt.dbid, dbname= DB_NAME (qt.dbid), qt.objectid,
10      qs.total_rows, qs.last_rows, qs.min_rows, qs.max_rows
11 FROM sys.dm_exec_query_stats AS qs
12 CROSS APPLY sys.dm_exec_sql_text(qs.sql_handle) AS qt
13 WHERE qt.text like '%SELECT%'
14 ORDER BY qs.execution_count DESC

1 如果目标数据库查询有问题，可以尝试切换成master DB

2 sql_handle的类型为 varbinary(64) ，在CLR里被转换成byte[]。可以使用 sys.fn_varbintohexstr(sql_handle)进行序列化。

3 dbcc freeProcCache 用来清除缓存

本文链接

Graceful Shutdown, Linger Options, and Socket Closure

2011-04-25T03:41:00Z

Client side	Server side
(1) Invokes shutdown(s, SD_SEND) to signal end of session and that client has no more data to send.
	(2) Receives FD_CLOSE, indicating graceful shutdown in progress and that all data has been received.
	(3) Sends any remaining response data.
(local timing significance only) Gets FD_READ and calls recv to get any response data sent by server .	(4) Invokes shutdown(s, SD_SEND) to indicate server has no more data to send.
(5) Receives FD_CLOSE indication.	(local timing significance only) Invokes closesocket .
(6) Invokes closesocket.

The following material is provided as clarification for the subject of shutting down socket connections closing the sockets. It is important to distinguish the difference between shutting down a socket connection and closing a socket.

Shutting down a socket connection involves an exchange of protocol messages between the two endpoints, hereafter referred to as a shutdown sequence. Two general classes of shutdown sequences are defined: graceful and abortive (also called hard). In a graceful shutdown sequence, any data that has been queued, but not yet transmitted can be sent prior to the connection being closed. In an abortive shutdown, any unsent data is lost. The occurrence of a shutdown sequence (graceful or abortive) can also be used to provide an FD_CLOSE indication to the associated applications signifying that a shutdown is in progress.

Closing a socket, on the other hand, causes the socket handle to become deallocated so that the application can no longer reference or use the socket in any manner.

In Windows Sockets, both the shutdown function, and the WSASendDisconnect function can be used to initiate a shutdown sequence, while the closesocketfunction is used to deallocate socket handles and free up any associated resources. Some amount of confusion arises, however, from the fact that the closesocketfunction implicitly causes a shutdown sequence to occur if it has not already happened. In fact, it has become a rather common programming practice to rely on this feature and to use closesocket to both initiate the shutdown sequence and deallocate the socket handle.

To facilitate this usage, the sockets interface provides for controls by way of the socket option mechanism that allow the programmer to indicate whether the implicit shutdown sequence should be graceful or abortive, and also whether the closesocket function should linger (that is not complete immediately) to allow time for a graceful shutdown sequence to complete. These important distinctions and the ramifications of using closesocket in this manner are still not widely understood.

By establishing appropriate values for the socket options SO_LINGER and SO_DONTLINGER, the following types of behavior can be obtained with the closesocketfunction:

Abortive shutdown sequence, immediate return from closesocket.
Graceful shutdown, delaying return until either shutdown sequence completes or a specified time interval elapses. If the time interval expires before the graceful shutdown sequence completes, an abortive shutdown sequence occurs, and closesocket returns.
Graceful shutdown, immediate return—allowing the shutdown sequence to complete in the background. Although this is the default behavior, the application has no way of knowing when (or whether) the graceful shutdown sequence actually completes.

The use of the SO_LINGER and SO_DONTLINGER socket options and the associated linger structure is discussed in more detail in the reference sections onSOL_SOCKET Socket Options and the linger structure.

One technique that can be used to minimize the chance of problems occurring during connection teardown is to avoid relying on an implicit shutdown being initiated by closesocket. Instead, use one of the two explicit shutdown functions, shutdown or WSASendDisconnect. This in turn causes an FD_CLOSE indication to be received by the peer application indicating that all pending data has been received. To illustrate this, the following table shows the functions that would be invoked by the client and server components of an application, where the client is responsible for initiating a graceful shutdown.

本文链接

Diagnostic utilities: TCP/IP

2011-04-25T03:04:00Z

Utility	Description
Arp	Allows viewing and editing of the Address Resolution Protocol (ARP) cache. The ARP cache contains software-to-hardware address mappings that are used for sending data on the local network. For more information, see Arp.
Hostname	Displays the host name of the computer as used for authentication by the Rcp, Rsh, and Rexec utilities. For more information, see Hostname.
Ipconfig	Displays current TCP/IP configuration values. Also used to manually release and renew a TCP/IP configuration lease assigned by a DHCP server and to reset DNS name registrations. For more information, see Ipconfig and Command-line utilities.
Lpq	Displays print queue status information on computers running Line Printer Daemon (LPD) print server software. For more information, see Lpq.
Nbtstat	Checks the state of current NetBIOS over TCP/IP connections, updates the Lmhosts cache, and determines the registered names and scope ID. For more information, see Nbtstat.
Netsh	Displays and administers TCP/IP protocol settings on either the local computer or a remote computer. For more information, see Netsh commands for Interface IP.
Netstat	Displays protocol statistics and information on current TCP/IP connections. For more information, see Netstat.
Nslookup	Checks records, domain host aliases, domain host services, and operating system information by querying DNS server. For more information, see Nslookup and Verify DNS registration for domain controllers using the nslookup command.
Ping	Verifies whether TCP/IP is configured correctly and tests connectivity to other host systems. For more information, see Ping and Test a TCP/IP configuration by using the ping command.
Route	Allows viewing and editing of the local IP routing table. For more information, see Route.
Tracert	Traces the network route taken by an IP datagram to its destination. For more information, see Tracert and Trace a path by using the tracert command.
Pathping	Traces the route a packet takes to a destination and displays information on packet losses for each router in the path. Pathping can also be used to troubleshoot Quality of Service (QoS) connectivity. For more information, see Using the pathping command.

本文链接

Photon Socket 术语表

2011-03-11T08:02:00Z

Photon概述

Photon是一个开发框架，用来构建实时MMO游戏，并支持多个平台。如同我们在Photon Socket 简介里介绍的一样，它包含一个Server SDK和一个Client SDK。

Photon提供一个低延时的通讯层，会根据需求选择TCP或UDP，来分别通过"可靠传输"和"非可靠传输"的方式发送"命令"。这些术语在本文都会有详细的解释。但在开始的时候，我希望大家明白，Photon是一个基于"操作"和"事件"的框架。这么做的目的是为了简化开发游戏系统的代价。这个系列的后续文章里我们会通过一系列例子来说明这点。

在服务器端，每一个独立的程序都被称作"线应用"(Lite Application)。它们内置了一些基础的"操作"，以使开发人员更关注他们的业务逻辑而非底层实现。

下面我们就开始介绍这些在开发中经常会使用术语或类。

Class LitePeer

我们从下面这个客户端的工作流开始，介绍一个最常见的Photon的运行步骤。大家可以大概理解一个服务器端程序是如何建立"房间"(Room)并且让用户"加入"(Join)进去。在"房间"中每一个用户都是一个"活动者"(Actor)，并有一个房间内唯一的标记。

创建一个LitePeer类的实例对象，并准备在下面步骤中调用该对象的方法
调用Connect()方法来尝试连接服务器，并通过实现IPhotonPeerListener.PeerStatusCallback来得到连接状态的通知，成功的状态是StatusCode.Connect。
周期性的调用Service()方法来获取事件，同时发送"命令"(比如每秒十次)
调用OpJoin()来加入游戏，通过实现OperationResult()来得到连接状态的通知，成功的状态是LiteOpCode.Join
调用OpRaiseEvent()向服务器发送数据
通过实现IPhotonPeerListener.EventAction()来获取服务器的数据更新
调用LitePeer.OpLeave()离开游戏，若OperationResult()返回LiteOpCode.Leave则表示服务器端已经确认成功离开。
调用Disconnect()以断开连接，通过PeerStatusCallback()得到连接状态的通知，StatusCode.Disconnect为成功断开连接。

通过上述流程，我们可以发现，这些已经介绍到的方法可以分为以下三类:

异步操作:比如Connect()，OpJoin()，OpRaiseEvent()，OpLeave()
异步回调:比如OperationResult()，用来返回异步主动操作的结果。值得注意的是，这种返回一般和异步操作是以一问一答的形式出现的。
事件:不确定合适会被触发，比如PeerStatusCallback()。

通讯层(Level)

PhotonServer SDK和Client SDK之间的通讯可以分为三个通讯层。

通讯层:Service, Connect, Disconnect 还有 StatusCallback这些都是直接对应连接状态的。它们和UDP/TCP协议都一一对应。
逻辑层:内置的"操作"，"状态"和"事件"都算作是逻辑层的一部分，我们可以通过方法的名称把它们分辨出来，比如OpJoin，OperationResult，PeerStatusCallback。
应用层:我们自己游戏中的业务逻辑一般被列在这个层中。比如我们可以通过实现OpCustom()，来发送自定义的"操作"。

大部分情况下，我们不必控制通讯层。然而了解客户端和服务器端的通讯机制依然有意义。

Interface IPhotonPeerListener

IPhotonPeerListener被定义来接受服务器端事件,下列方法需要被实现。

PeerStatusCallback:用来得到通讯层的连接状态变化的通知，比如connect, disconnect, errors, compare，这些状态都被定义在StatusCode这个枚举里。
OperationResult:用来得到逻辑层操作的回调，比如(join, leave)
EventAction:用来得到应用层的事件回调
DebugReturn:只在调试中使用

同时下列属性也值得关注

TimePingInterval:设置客户端对服务器的Ping间隔
RoundTripTime:用来指定"可靠信道"的往返间隔。可以简单理解为，在"可靠信道"里发送数据包的时候，依靠RoundTripTime和RoundTripTimeVariance来判断单位时间内响应是否超时。
RoundTripTimeVariance:RoundTripTime允许的方差。
ServerTimeInMilliSeconds:服务器端的计时器，以微秒为单位。

操作(Operation)

操作是我们用来描述对Photon服务器远程方法调用(RPC)的术语。也就是说，操作是在服务器端被实现，然而在客户端被调用。就像所有的方法，他们有参数和返回值。Photon负责处理操作的调用机制，而我们只需要定义和调用即可。

在服务器端，操作运行于Photon内核之上。默认由Exit Games(Photon开发公司)提供的服务器端程序叫做线应用(Lite Application)。LitePeer类继承自PhotonPeer并实现了所有被继承的基础操作的方法。

关于这些基础操作，最典型的例子就是join和raise event。在客户端，这两个操作对应的就是LitePeer类的OpJoin和OpRaiseEvent这两个方法。由于他们已经被LitePeer实现了，所以在应用层你可以放心来调用。

自定义操作(Custom Operation)

Photon是可拓展的。比如游戏程序中，你可能需要在服务器端持久化游戏世界的某些状态，也需要在客户端确认这些信息是否同步。所以你需要自己实现一些业务逻辑，所有这些没有被内置实现的操作都叫做自定义操作。实现这些操作一般都是服务器端程序员的工作，而调用这些远程方法及更新客户端则是客户端程序员的工作。

在定义自定义操作的时候，名字和参数数目是不受限制的，但为了节省带宽，这些操作名和参数是会被二进制化成字节码。事实上，Photon会用一个唯一的code标识每一个操作，这个code就被称为操作码(opCode)。

在调用自定义操作就是在客户端调用OpCustom()，Photon发送一个哈希表的数据结构来调用远程方法。

事件(Event)

不像操作是主动调用的方法，事件是通过暴露回调方法来得到通知。事件可能是由服务器端或者其他客户端发出的。

一般来说，得到事件的通知是由于受到操作的影响，比如你进入一个游戏房间，这个房间里的其他客户端应该得到通知。当然有自定义操作就有自定义事件。大部分事件带有关于这个事件的描述数据，这也是用哈希表来作为数据结构的。

段(Fragmentation)

超过1KB的数据都会被拆成以1KB为单位的消息包，并且会在传输到对点之后自动重组。这就意味着有些包含很大数据量的命令会导致其后的命令延时。所以经常调用Service() 或 SendOutgoingCommands()是绝对必要的。你可以检查PhotonPeer.QueuedOutgoingCommands这个属性是否归零来了解是否队列里的命令是否都发出去了。你也可以检查debug输出里的是否有"UDP package is full",这有时候是会发生的。

非可信数据(Unreliable data)

有些数据需要保证其实时，然而对其准确性和丢失率并无很高要求，这类数据被称为非可信数据。有些数据要求务必准确，并且需要保证发送的顺序即接收的顺序，这类数据被称为可信数据。事实上，可信数据一般基于TCP协议，而非可信数据基于UDP协议。当然，TCP的通讯效率明显低于UDP，而且是单播的，UDP却可以组播。

在游戏程序中，我们可以根据需求来使用这两种传输方式。比如在FPS游戏中，移动信息可以作为非可信数据，因为其要频繁更新，并且可以接受一定的误差因为可以很快被之后的消息更正，而对话信息则必须是可信数据，因为顺序错误或者消息丢失是不能被接受的。

信道(Channels)

.net的客户端已经支持多信道。这个特性允许客户端和服务器之间可以并行传输消息。这就意味，如果我们把某些特别容易造成延时的命令或事件放在一个独立的信道里，它就不会导致那些有实时性要求的数据等待太久。当然你不可以跨信道发送事件。

默认情况下，每一个PhotonPeer对象实例有两条信道，并且0号信道是默认用来发送操作的信道。而如加入房间或离开房间则是通过2号信道发送的，这么做是为了让业务更清楚。在这两条以外其实还有一条后台信道，即255号信道，用来发送网络连接和断开的消息，这样我们就可以把主动断开网络和意外性的断开网络封装成一种情况。

信道也是分优先级的，低号码的信道会被放在UDP协议来优先发送。举例来说，对话消息可能会被放在1号信道，而移动消息则被放到0号信道。那么当聊天信息发送延时的时候，不会导致实时性要求更高的移动消息被阻塞。

TCP

如Flash或Silverlight的客户端是不支持的UDP协议的，这就意味着我们只能把TCP协议作为最底层协议。这虽然不是使用Photon的最佳实践，但也只能如此。

而在TCP协议下，我们无法使用非可信数据的传输效率高和组播这样的特性。当然，我们的业务代码也可以简化很多。

可序列化数据类型(Serializable Datatypes)

从服务器SDK 1.8.0和.net客户端5.6.0开始，Photon支持的可序列化数据类型有了一次大的变化。ArrayList(弱类型数组)被放弃，而Arrays(强类型数组)和Hashtable被支持。具体可以参考以下列表:

String / string
Boolean / bool
Byte / byte (unsigned)
Int16 / short (signed)
Int32 / int (signed)
Int64 / long
Single / float
Double / double
Array (支持以上类型的强类型数组, 但长度限于 Short.MaxValue，而且二位数组是不被支持的。 )
Hashtable (需注意的是Hashtable[] 是不被支持的。对一个Hashtable对象，虽然可以同时使用不同类型的数值作为它的键，但从传输性能上考虑，最好不要出现这种情况。因为一旦出现一个Hashtable的键有多个类型的情况，该对象的读取会被拆成多个子命令，每一个键都会需要一个子命令。)

组播属性(broadcasting Property)

线应用可以用来在服务器端为客户端维护数据一致性，在同一个房间的玩家需要将彼此的数据同步，而对客户端而言，整个过程也许就像是读写对象的属性一样。

通过Photon内置的组播选项可以轻松的实现组播属性的功能。在服务器端的属性发生改变时，响应的事件会被触发以通知所有需要被通知的玩家更新数据，除了属性的修改者(因为这是不需要的)。

下列方法就是用来将属性写回服务器端:

LitePeer.OpSetPropertiesOfActor
LitePeer.OpSetPropertiesOfGame
LitePeer.OpJoin(值得一提的是，玩家可以加入一个还没有被创建出来的游戏房价，也就是说，服务器端不会对加入的房间做检查，你需要自己来完成)

而下列方法用来从服务器端读取属性并缓存在客户端本地:

OpGetPropertiesOfActor
OpGetPropertiesOfGame

需要注意的是，线应用目前不支持删除属性，也不支持用含宽字符的字符串作为组播属性的键值。而属性方法(.net中可以把方法包装成属性)也暂时不被支持。

本文链接

Photon Socket 简介

2011-02-26T19:46:00Z

Photon 是什么

Photon原意是指光量子。在这里是指exitgames开发的MMO服务器端引擎。

Photon包含两个部分。一部分是一个socket服务器，另一部分是其针对各个平台编写的sdk。这些平台包括了:android, Flash, iPhone, iPad, .NET., Unity 3D, Windows,甚至还有silverlight。这也意味着Photon的发布也包括两个部分，Client SDK Release和Server SDK Update。目前Server SDK的版本是v2.4.5，而Client SDK的版本是v6.2.0。

Photon 和其他MMO服务器端引擎有什么不同

这里有一幅图可以供大家参考。

当然还有几处是值得一提的：

Photon的API已经不限于C#了。
Photon可以支持HTTP，则意味着它或许还可以作为其他用途，比方说专用的Ajax服务器。
Photon的socket server是用c++实现的，效率自然不是java可以比拟的。
Photon已经通过私有协议完成对象的二进制序列化。大家也不必操心去笨手笨脚的自己去实现了。
Photon支持UDP。对于某些需求来说，这就具备了技术上的可行性了。

Photon 的实际应用

事实上Photon和Unity3d之间的合作是有战略意义的。了解Unity3d的朋友一定知道island这个sample。这里有一段视频就是展示如何在Unity3d中使用Photon Client SDK。不得不说，Photon和Unity3d的风格很接近:支持广泛，效率良好，易于上手。

Photon 的更多内容

以后会一一道来。当然欢迎大家来此群26981338讨论。

本文链接