C custom set

Main collection classes

Interface level interface structure

List collection ：List<T>

Custom collection sorting

Each element can be accessed individually by index ,List<T> It's an ordered set , Calling the built-in method Sort() Then the elements will be reordered alphabetically .

If the element type implements generics IComparable<T> Or non generic interfaces IComparable By default, the sorting algorithm uses it to determine the sorting order .

If not , Or the default logic does not meet the requirements , You can call List<T>.Sort() The overloaded version of , He got one IComparaer<T> As an argument

IComparable<T> and IComparaer<T> The difference is that , The former Know how to compare myself with another instance of the same type , the latter Know how to compare two instances of a given type

When implementing sorting logic, ensure full order , Ensure that the permutation and combination of the same data will produce consistent results , For example, judgment is transitive , Equal to itself …

It is worth noting that , No element in the judgment can be null It returns equal , Otherwise, two non null Elements are equal to null But they are not equal to each other ,null Different values should be returned on the left and right sides of the identifier

Dictionaries ：Dictionary<TKey,TValue>

var colorMap = new Dictionary<string, ConsoleColor>{
    ["Error"] = ConsoleColor.Red;
    ["Warning"] = ConsoleColor.Yellow;
}

// Two ways of inserting , The latter can also be used to change 
colorMap.Add("Information", ConsoleColor.Green);
colorMap["Verbose"] = ConsoleColor.White;

//foreach Ergodic dictionary 
private static void Print( IEnumerable<KeyValuePair<string, ConsoleColor>> items){
    	foreach(KeyValuePair<string, ConsoleColor> item in items){
            Console.WriteLine(item.Key);
        }
}

Again , The order of the elements in the dictionary is not certain , Don't rely on it

The dictionary is to determine whether it matches the existing key , If the dictionary value is customized , It is necessary to realize the judgment logic , In addition, we need to implement a return “ Hash code ” Methods to quickly index

Indexer

Array , Both dictionaries and lists provide indexers , You can define your own indexer

// Defines a set containing only two elements 
public enum PairItem{
    First,
    Second
}

public struct Pair<T> {
	public Pair(T first, Tsecond){
		First = first;
        Second = second;
    }
    
    public T First { get; }
    public T Second { get; }
	
    public T this[PairItem index]{
		get{
			switch(index){
                case PairItem.First:
                    return First;
                case PairItem.Second:
                    return Second;  
                default:
                    throw new NotImplementedException(
                    	string.Format("The enum {0} has not been implemented"), index.ToString())
                        );
            }
        }
    }
    // It is very similar to the declaration of attributes , But use keywords this, Included later [ parameter list ], Can have multiple parameters 
    // If the set is empty , It's better not to go back null,
    // Instead, it returns a collection instance that does not contain any data items , have access to Enumerable.Empty<T>() To generate 
  	// This eliminates the need to check before traversing the collection elements null value 
}

iterator

foreach loop

The first element is determined , The next element and the last element do not need to know the total number of elements

Look at this picture again ,IEnumerable The only way to do it is GetEnumerator() The function is to return support IEnumerator<T> An object of , It is equivalent to a bookmark to make the loop interleave through a set without interfering with each other .

foreach use while The equivalent code of is as follows

Stack<int> stack = new Stack<int>();
int number;
Stack<int>.Enumerator enumerator;

enumerator = stack.GetEnumerator();
while(enumerator.MoveNext()){
	number = enumerator.Current;
	Console.WriteLine(number);
}

From the code, we can also see why the compiler prohibits number Assign a value , Because it's only a local variable , It doesn't change the set element itself .

Iterators generate values

Iterators are similar to functions , But it is not the return value (return), Instead, generate values （yield）.

Why? yield Add return Well , because C# Experts believe that adding a new keyword just for this situation is not enough , So will yield return Whole as a keyword ,yield Nothing happens when it appears alone .

Every time the iterator encounters yield return Will generate a value , Immediately return to the caller of the requested data item . Then when requesting the next item , Will be followed by the last yield return Execute after statement .

foreach Each cycle of is represented by a MoveNext Start , After generating a value, return it to foreach sentence . perform yield return after , GetEnumerator() Method pauses and waits for the next MoveNext()

If you need to cancel the iteration , Then yield break Immediately return control to the caller and terminate the loop

Query expression

C# For a set, you can filter the set through a query expression , And project the set . His grammar and SQL The language is as like as two peas.

static string[] Keywords = {"abstract", "add*", "alias", "async*"};

private static void ShowSpeacilWords{
	IEnumerable<string> selection =
        form word in Keywords
        	where !word.Contains('*')
        	select word;
    foreach(string keyword in selection){
        Console.Write(keyword + "");
    }
}

and SQL The main difference between sentences is C# The sentence order of the query expression is from、where、select, and SQL The sentence is SELECT、FROM、WHERE

Besides, there are group by,order by Wait for a series of keywords

private static void GroupKeyword(){
    IEnumerable<IGrouping<bool,string>> selection =
        from word in Keyword
        group word by word.Contains('*');
}