Джозеф Албахари Бен Албахари Карманны справочник 2017

/

Джозеф Албахари, Бен Албахари - C# 7.0. Карманный справочник - 2017.pdf

/.../[01] A First C# Program (and notes on LINQPad)/

[01] A First C# Program.linq

[02] A First C# Program - simplified.linq

[02] Statement Mode.linq

[03] Statement Mode with Dump.linq

[04] Note on Selective Execution in LINQPad.linq

[05] Expressions in LINQPad.linq

[06] First Program Refactored.linq

/.../[02] Syntax Basics/

[01] The @ prefix.linq

[02] Contextual Keywords.linq

[03] Semicolons and Comments.linq

/.../[03] Type Basics/

[01] Predefined Type Examples.linq

[03] Custom Type Examples.linq

[05] Instance vs Static Members.linq

[07] Conversions.linq

[09] Value Types.linq

[11] Reference Types.linq

[13] Null.linq

[15] Nulls with structs.linq

[17] Storage Overhead.linq

/.../[04] Numeric Types/

[00] Numeric Types.linq

[01] Numeric Literals.linq

[02] Numeric Suffixes.linq

[03] Numeric Conversions.linq

[05] Increment and Decrement Operators.linq

[07] Integral Division.linq

[09] Integral Overflow.linq

[12] Overflow Checking.linq

[14] Overflow Checking with Constant Expressions.linq

[16] 8- and 16-bit literals.linq

[18] Special float and double Values.linq

[20] Real Number Rounding Errors.linq

/.../[05] Boolean Type and Operators/

[01] Equality and Comparison Operators.linq

[02] Equality with Reference Types.linq

[03] And & Or Operators.linq

[04] Shortcircuiting.linq

[06] And & Or Operators - non-shortcircuiting.linq

[08] Conditional operator (ternary).linq

/.../[06] Strings and Characters/

[01] Character literals.linq

[02] Character conversions.linq

[03] String literals.linq

[04] String concatenation.linq

[06] String interpolation.linq

/.../[02] Chapter 2 - C# Language Basics/[07] Arrays/

[01] Arrays.linq

[02] Default Element Initialization.linq

[03] Default Element Initialization - Reference Types.linq

[03] Default Element Initialization - Value Types.linq

[05] Multidimensional Arrays - Rectangular.linq

[06] Multidimensional Arrays - Jagged.linq

[08] Simplified Array Initialization Expressions.linq

[08] Simplified Array Initialization with Implicit Typing.linq

[10] Bounds Checking.linq

/.../[08] Variables and Parameters/

[01] Stack.linq

[02] Heap.linq

[03] Definite Assignment - Local Variables.linq

[04] Definite Assignment - Array Elements.linq

[05] Definite Assignment - Fields.linq

[10] Parameters - Passing by Value.linq

[11] Parameters - Passing by Value (reference types).linq

[12] Parameters - The ref Modifier.linq

[13] Parameters - The ref Modifier - Swap Method.linq

[15] Parameters - The out Modifier.linq

[16] Parameters - Implications of Passing By Reference.linq

[20] Parameters - The params modifier.linq

[30] Parameters - Optional Parameters.linq

[32] Parameters - Named Arguments.linq

[33] Parameters - Optional Parameters with Named Arguments.linq

[33] var - Implicitly Typed Variables.linq

[34] Implicitly Typed Variables are Statically Typed.linq

[35] Implicitly Typed Variables and Readability.linq

/.../[09] Expressions and Operators/

[01] Primary Expressions.linq

[02] Assignment Expressions.linq

[03] Precedence.linq

[04] Left Associativity.linq

[05] Right Associativity.linq

/.../[10] Null Operators/

[01] Null Coalescing Operator.linq

[02] Null-Conditional Operator.linq

[03] Null-Conditional Operator - with nullable types.linq

/.../[02] Chapter 2 - C# Language Basics/[11] Statements/

[10] Declaration Statements.linq

[11] Declaration Statements - Constants.linq

[12] Declaration Statements - Local Variables.linq

[13] Expression Statements.linq

[21] if statement.linq

[22] else clause.linq

[25] Changing Execution Flow with Braces.linq

[27] Omitting Braces.linq

[28] switch Statement.linq

[29] switch Statement - Stacking Cases.linq

[40] while loop.linq

[41] do-while loop.linq

[42] for loop.linq

[43] foreach loop.linq

[50] break statement.linq

[51] continue statement.linq

[53] goto statement.linq

[55] return statement.linq

/.../[02] Chapter 2 - C# Language Basics/[12] Namespaces/

Namepsaces.linq

/.../[03] Chapter 3 - Creating Types in C#/[01] Classes/

[01] Fields.linq

[02] Fields - readonly.linq

[03] Methods - Expression-bodied.linq

[03] Methods - Overloading.linq

[04] Methods - Illegal Overloading.linq

[10] Constructors - Overloading.linq

[11] Constructors - Nonpublic.linq

[15] Object Initializers.linq

[16] Object Initializer Alternative - Optional Parameters.linq

[18] The this Reference.linq

[20] Properties.linq

[21] Properties - calculated & read-only.linq

[21] Properties - expression-bodied.linq

[22] Automatic Properties.linq

[22] Property Initializers.linq

[24] Properties - get & set accessibility.linq

[30] Indexers.linq

[40] Constants - scoped to class.linq

[41] Constants - scoped to method.linq

[45] Static Constructors.linq

[46] Static Constructors & Field Initialization Order.linq

[47] Static Constructors & Field Initialization Order (Constructor Call).linq

[50] Partial Types.linq

[52] Partial Methods.linq

[55] The nameof operator.linq

/.../[03] Chapter 3 - Creating Types in C#/[02] Inheritance/

[01] Inheritance.linq

[02] Polymorphism.linq

[04] Reference Conversions - Upcasting.linq

[05] Reference Conversions - Downcasting.linq

[07] The is operator.linq

[09] The as operator.linq

[12] Virtual Function Members.linq

[13] Abstract Classes & Members.linq

[15] Hiding Inherited Members with new.linq

[17] new vs virtual.linq

[20] Sealing Functions & Classes.linq

[25] Constructors & Inheritance.linq

[26] Implicit Calling of the Parameterless Base Class Constructor.linq

[28] Overloading and Resolution.linq

/.../[03] The object Type/

[01] The object Type.linq

[03] Boxing & Unboxing.linq

[04] Unboxing to Wrong Type.linq

[05] Unboxing to Wrong Type - Fix.linq

[07] Copying Semantics of Boxing & Unboxing.linq

[10] GetType and typeof.linq

[12] The ToString Method.linq

/.../[03] Chapter 3 - Creating Types in C#/[04] Structs/

[01] Structs.linq

[02] Structs - Illegal Construction Examples.linq

/.../[05] Access Modifiers/

[01] Access Modifiers - Examples.linq

[02] Friend Assemblies.linq

[05] Accessibility Capping.linq

[07] Restrictions on Access Modifiers.linq

/.../[03] Chapter 3 - Creating Types in C#/[06] Interfaces/

[01] Interfaces.linq

[03] Extending an Interface.linq

[05] Explicit Interface Implementation.linq

[07] Implementing Interface Members Virtually.linq

[10] Reimplementing an Interface in a Subclass.linq

[11] Reimplementing an Interface - Contrast.linq

[15] Alternatives to interface reimplementation.linq

[18] Interfaces and Boxing.linq

/.../[03] Chapter 3 - Creating Types in C#/[07] Enums/

[01] Enums.linq

[03] Enum Conversions.linq

[05] Flags Enums.linq

[06] Flags Enums - Combinations.linq

[10] Type-Safety Issues.linq

[12] Type-Safety Issues - Workaround.linq

/.../[08] Nested Types/

[01] Nested Types.linq

[02] Nested Types - Private Member Visibility.linq

[03] Nested Types - Protected Member Visibility.linq

/.../[03] Chapter 3 - Creating Types in C#/[09] Generics/

[01] Generic Types.linq

[02] Why Generics Exist.linq

[05] Generic Methods.linq

[07] Declaring Type Parameters.linq

[10] Typeof and Unbound Generic Types.linq

[12] The default Generic Value.linq

[15] Generic Constraints.linq

[16] Parameterless Constructor Constraint.linq

[18] Naked Type Constraint.linq

[20] Subclassing Generic Typest.linq

[22] Self-Referencing Generic Declarations.linq

[25] Static Data.linq

[30] Type Parameters & Conversions - Problem.linq

[31] Type Parameters & Conversions - Solution #1.linq

[32] Type Parameters & Conversions - Solution #2.linq

[33] Type Parameters & Conversions - Unboxing.linq

[40] Covariance - Classes - Problem.linq

[41] Covariance - Classes - Hindering Reusability.linq

[42] Covariance - Classes - Workaround.linq

[45] Covariance - Arrays.linq

[50] Covariance - Interfaces.linq

[52] Contravariance - Interfaces.linq

[53] Contravariance - More Examples.linq

/.../[04] Chapter 4 - Advanced C#/[01] Delegates/

[01] Delegates.linq

[02] Delegates - longhand.linq

[05] Delegates - Writing Plug-in Methods.linq

[10] Multicast Delegates.linq

[11] Multicast Delegates - ProgressReporter.linq

[15] Instance vs Static Methods.linq

[17] Generic Delegate Types.linq

[20] Func and Action Delegates.linq

[22] Delegates vs Interfaces.linq

[23] Delegates vs Interfaces - Clumsiness.linq

[25] Delegate Type Incompatibility.linq

[26] Delegate Type Incompatibility - Workaround.linq

[27] Delegate Equality.linq

[30] Parameter Compatibility (Contravariance).linq

[31] Return Type Compatibility (Covariance).linq

[35] Type Parameter Variance.linq

/.../[04] Chapter 4 - Advanced C#/[02] Events/

[01] Events.linq

[05] Standard Event Pattern.linq

[06] Standard Event Pattern - Simple EventHandler.linq

[08] Event Accessors.linq

[10] Event Accessors - Interfaces.linq

/.../[03] Lambda Expressions/

[01] Lambda Expressions.linq

[03] Capturing Outer Variables.linq

[05] Capturing Outer Variables - Lifetime.linq

[06] Capturing Outer Variables - Uniqueness.linq

[10] Capturing Iteration Variables.linq

[11] Capturing Iteration Variables - Workaround.linq

[12] Anonymous Methods.linq

/.../[04] try Statements and Exceptions/

[01] DivideByZeroException unhandled.linq

[02] DivideByZeroException handled.linq

[05] The catch Clause.linq

[06] Exception Filters.linq

[07] The finally Block.linq

[09] The using Statement.linq

[20] Throwing Exceptions.linq

[22] Rethrowing an Exception.linq

[23] Rethrowing More Specific Exception.linq

[25] The TryXXX Pattern.linq

[27] The Atomicity Pattern.linq

file.txt

/.../[05] Enumeration and Iterators (see also CH7)/

[01] Enumeration.linq

[02] Collection Initializers.linq

[03] Collection Initializers - dictionaries.linq

[04] Iterators.linq

[04] yield break.linq

[05] Multiple yield Statements.linq

[08] Iterators and try-catch blocks.linq

[10] Iterators and try-finally blocks.linq

[15] Composing Iterators.linq

/.../[06] Nullable Types/

[01] Nullable Types.linq

[03] Implicit and Explicit Nullable Conversions.linq

[05] Boxing and Unboxing Nullable Values.linq

[07] Operator Lifting.linq

[08] Operator Lifting - More Examples.linq

[10] Operator Lifting - Equality Operators.linq

[12] Operator Lifting - Relational Operators.linq

[14] All Other Operators (except for And+Or).linq

[16] Mixing Nullable and Nonnullable Operators.linq

[18] And+Or operators.linq

[20] Null Coalescing Operator.linq

[21] Null-Conditional Operator.linq

[22] Scenarios for Nullable Types.linq

/.../[07] Operator Overloading (see also CH6)/

[01] Operator Functions.linq

[02] Custom Implicit and Explicit Conversions.linq

[05] Overloading true and false.linq

/.../[08] Extension Methods/

[01] Extension Methods.linq

[02] Extension Method Chaining.linq

[05] Extension Methods vs Instance Methods.linq

[06] Extension Methods vs Extension Methods.linq

[08] Extension Methods on Interfaces.linq

/.../[09] Anonymous Types/

[01] Anonymous Types.linq

[02] Anonymous Types - Omitting Identifiers.linq

[04] Anonymous Types - Identity.linq

/.../[10] Dynamic Binding (see also CH20)/

[01] Custom Binding.linq

[05] Language Binding.linq

[10] RuntimeBinderException.linq

[12] Runtime Representation of Dynamic.linq

[15] Dynamic Conversions.linq

[17] var vs dynamic.linq

[18] Static type of var can be dynamic.linq

[20] Dynamic Expressions.linq

[25] Dynamic Calls without Dynamic Receivers.linq

[26] Static Types in Dynamic Expressions.linq

[30] Uncallable Functions.linq

/.../[11] Attributes (see also CH19)/

Attributes.linq

Caller Info Attributes.linq

/.../[12] Unsafe Code and Pointers (see also CH25)/

[01] Unsafe Code.linq

[02] Pinning variables with fixed.linq

[05] The Pointer-to-Member Operator.linq

[10] The stackalloc keyword.linq

[12] Fixed-Size Buffers.linq

[14] void-star.linq

/.../[01] String and Text Handling/

[01] Char.linq

[02] ToUpper & ToLower - and the Turkey bug.linq

[05] Constructing strings.linq

[06] Null and Empty Strings.linq

[08] Accessing Characaters within a string.linq

[09] Searching within strings.linq

[12] Manipulating strings.linq

[14] Splitting & Joining strings.linq

[16] string.Format and Compostite Format Strings.linq

[17] Comparing strings.linq

[20] StringBuilder.linq

[22] Text Encodings and Unicode.linq

[24] Encoding to byte Arrays.linq

[25] UTF-16 and SurrogatePairs.linq

/.../[02] Dates and Times/

[01] TimeSpan.linq

[02] TimeSpan - Properties.linq

[04] Constructing a DateTime or DateTimeOffset.linq

[05] DateTime - Specifying a Calendar.linq

[07] Choosing between DateTime & DateTimeOffset.linq

[10] The Current DateTime or DateTimeOffset.linq

[12] Working with Dates & Times.linq

[14] Formatting & Parsing.linq

/.../[03] Dates and Time Zones/

[01] DateTime and Time Zones.linq

[02] DateTimeOffset and Time Zones.linq

[05] TimeZone.linq

[07] TimeZoneInfo.linq

[10] TimeZoneInfo - Adjustment Rules.linq

[12] How we Found Western Australia.linq

[15] Daylight Saving and DateTime.linq

/.../[04] Formatting and Parsing/

[01] ToString and Parse.linq

[03] Format Providers.linq

[05] Format Providers and CultureInfo.linq

[07] Using NumberFormatInfo or DateTimeFormatInfo.linq

[09] Composite Formatting.linq

[12] Parsing with Format Providers.linq

[15] IFormatProvider and ICustomFormatter.linq

[20] Standard Format Strings and Parsing Flags.linq

[22] NumberStyles.linq

[24] Parsing and misparsing DateTimes.linq

[26] Enum Format Strings.linq

/.../[05] Other Conversion Mechanisms/

[01] Convert.linq

[03] XmlConvert.linq

[05] BitConverter.linq

[05] Type Converters.linq

/.../[06] Working with Numbers/

[01] BigInteger.linq

[03] Complex Numbers.linq

[05] Random.linq

/.../[06] Chapter 6 - Framework Fundamentals/[07] Enums/

[01] Type Unification.linq

[03] Enum to Integral Conversions.linq

[05] Integral to enum Conversions.linq

[05] String Conversions.linq

[07] Enumerating enum Values.linq

/.../[06] Chapter 6 - Framework Fundamentals/[08] Tuples/

[01] Tuples.linq

[02] Comparing Tuples.linq

/.../[09] The Guid Struct/

[01] Guid.linq

/.../[10] Equality Comparison/

[01] Value vs Referential Equality.linq

[03] == and !=.linq

[05] Virtual Equals Method.linq

[07] Static Equals Method.linq

[08] EqualityComparer.linq

[12] The static ReferenceEquals method.linq

[15] The IEquatable Interface.linq

[20] When Equals and == are not Equal.linq

[22] Customizing Equality - Full Example.linq

/.../[11] Order Comparison/

[01] Order Comparison.linq

[03] IComparable.linq

[05] LessThan & GreaterThan operators.linq

[10] Customizing Order Comparision - Full Example.linq

/.../[07] Chapter 7 - Collections/[01] Enumeration/

[01] Low-level use of IEnumerable and IEnumerator.linq

[02] Disposing enumerators.linq

[03] Use of nongeneric interfaces.linq

[10] Simple iterator class.linq

[11] Simple iterator class - generic.linq

[15] Iterator method.linq

[20] Low-level approach - nongeneric.linq

[22] Low-level approach - generic.linq

/.../[02] ICollection and IList/

ICollection and IList.linq

/.../[07] Chapter 7 - Collections/[03] Arrays/

[01] Referential vs structural comparisons.linq

[02] Shallow array clone.linq

[05] Construction and indexing.linq

[07] Print first element of array.linq

[10] Enumeration.linq

[12] Searching arrays.linq

[14] Sorting arrays.linq

[16] Sorting arrays with lambda.linq

[18] Converting arrays.linq

/.../[04] Lists, Queues, Stacks and Sets/

[01] Generic List class.linq

[02] Old ArrayList class.linq

[05] LinkedList.linq

[06] Queue.linq

[08] Stack.linq

[10] BitArray.linq

[20] HashSet and SortedSet.linq

[22] HashSet and SortedSet - set operators.linq

/.../[07] Chapter 7 - Collections/[05] Dictionaries/

[01] Dictionary.linq

[03] SortedDictionary and SortedList.linq

/.../[06] Customizable Collections and Proxies/

[01] Using System.Collections.ObjectModel.Collection.linq

[02] Extending previous example.linq

[05] KeyedCollection.linq

[08] ReadOnlyCollection.linq

/.../[07] Plugging in Equality and Order/

[01] IEqualityComparer and EqualityComparer.linq

[05] IComparer and Comparer.linq

[06] IComparer and Comparer - SurnameComparer.linq

[10] StringComparer.linq

[15] Culture-aware SurnameComarer.linq

[20] IStructuralEquatable and IStructuralComparable.linq

/.../[01] Threading Basics/

[01] Creating a thread.linq

[02] Join.linq

[03] Sleep.linq

[05] Local state.linq

[06] Shared state - unsafe.linq

[07] Shared state with closure - unsafe.linq

[08] Shared state with statics - unsafe.linq

[10] Shared state - safe.linq

[12] Passing in data with a lambda expression.linq

[13] Multi-statement lambda.linq

[15] Lambdas and captured variables - unsafe.linq

[16] Lambdas and captured variables - safe.linq

[20] Exception handling - wrong place.linq

[21] Exception handling - right place.linq

[25] Basic signaling.linq

[30] Threading in rich-client apps.linq

[32] Synchronization contexts.linq

[35] Entering the ThreadPool.linq

/.../[14] Chapter 14 - Concurrency and Asynchrony/[05] Tasks/

[01] Starting a Task.linq

[02] Wait.linq

[05] Long-running task.linq

[06] Returning a value.linq

[07] Count prime numbers.linq

[10] Exceptions.linq

[20] Continuations - GetAwaiter.linq

[21] Continuations - ContinueWith.linq

[25] TaskCompletionSource - Print 42 after 5 seconds.linq

[26] TaskCompletionSource - Our own Run method.linq

[28] TaskCompletionSource - GetAnswerToLife.linq

[30] Writing Delay method.linq

[35] Delay times 10000.linq

[40] Task.Delay.linq

/.../[10] Principles of Asynchrony/

[01] GetPrimesCount.linq

[05] Course-grained asynchrony.linq

[10] Fine-grained asynchrony.linq

[15] Making DisplayPrimesCount asynchronous.linq

[20] Asynchronous functions to the rescue.linq

/.../[15] Asynchronous Functions in C# 5.0/

[01] Awaiting.linq

[05] Capturing local state.linq

[10] Awaiting in a UI - synchronous.linq

[15] Awaiting in a UI - asynchronous.linq

[20] Awaiting in a UI - IO-bound.linq

[25] Awaiting in a UI - Comparison to course-grained concurrency.linq

[30] Writing asynchronous functions.linq

[32] Returning Task of TResult.linq

[33] Blocking versions of the above.linq

[35] Parallelism.linq

[40] Asynchronous lambda expressions.linq

[42] Asynchronous lambda expressions - event handlers.linq

[45] Asynchronous lambda expressions - returning Task of TResult.linq

[50] Optimizations - Completing synchronously.linq

[52] Optimizations - Caching Tasks.linq

[55] Optimizations - Caching Tasks fully threadsafe.linq

[58] Optimizations - Avoiding excessive bouncing.linq

/.../[20] Asynchronous Patterns/

[01] Cancellation.linq

[05] Using the real CancellationToken.linq

[10] Using the real CancellationToken - improved version.linq

[15] Progress reporting - with a delegate.linq

[17] Progress reporting - with IProgress.linq

[20] Task combinators - WhenAny.linq

[22] Task combinators - WhenAny - await winning task.linq

[25] Task combinators - WhenAny - in one step.linq

[27] Task combinators - WhenAny - timeouts.linq

[30] Task combinators - WhenAll.linq

[32] Task combinators - WhenAll - exceptions.linq

[35] Task combinators - WhenAll - return values.linq

[37] Task combinators - WhenAll - web page downloads.linq

[40] Task combinators - WhenAll - web page downloads improved.linq

[45] Custom combinators - WithTimeout.linq

[50] Custom combinators - WithCancellation.linq

[57] Custom combinators - WhenAllOrError.linq

/.../[20] Chapter 20 - Dynamic Programming/

[01] Numeric type unification.linq

[02] Numeric type unification - typesafe.linq

[05] Numeric type unification - with static overloads.linq

[10] Visitor pattern.linq

[11] Visitor pattern - with abstract base class.linq

[20] Anonymously calling members of generic type.linq

[21] Anonymously calling members of generic type with multiple dispatch.linq

[22] Anonymously calling members of generic type - IGrouping.linq

[25] DynamicObject - dynamic XAttributes.linq

[27] DynamicObject - dynamic DataReader.linq

[28] DynamicObject - TryBinaryOperation and TryInvoke.linq

[30] ExpandoObject.linq

[40] Python calculator.linq

[42] Python interop - passing state.linq

[43] Python interop - returning variables.linq

[44] Python interop - type marshaling.linq

/.../[01] Exclusive Locking/

[01] Simple use of lock.linq

[05] Nested locking.linq

[07] Deadlocks.linq

[10] Mutex.linq

/.../[02] Locking and Thread Safety/

[01] Thread safety and .NET Framework types.linq

[05] Thread safety in application servers.linq

[10] Semaphore.linq

[15] ReaderWriterLockSlim.linq

[20] ReaderWriterLockSlim - upgradeable locks.linq

[25] ReaderWriterLockSlim - lock recursion.linq

/.../[05] Signaling with Event Wait Handles/

[01] AutoResetEvent.linq

[05] Two-way signaling.linq

[10] CountdownEvent.linq

[15] Wait Handles and continuations.linq

[20] Converting Wait Handles to Tasks.linq

/.../[10] The Barrier Class/

[01] Barrier.linq

[05] Barrier - post-phase action.linq

/.../[15] Lazy Initialization/

[01] Intro.linq

[05] Intro - with lock.linq

[10] Lazy of T.linq

[15] LazyInitializer.linq

/.../[20] Thread-local Storage/

[01] ThreadStatic.linq

[05] ThreadLocal.linq

[10] GetData and SetData.linq

/.../[25] Suspend and Resume/

[01] Obtaining stack trace.linq

/.../[22] Chapter 22 - Advanced Threading/[30] Timers/

[01] Multithreaded timers - Threading Timer.linq

[05] Multithreaded timers - System.Timer.linq

/.../[40] EXTRA - Wait and Pulse/

[01] Signaling with Wait and Pulse.linq

[05] Now not to use Wait and Pulse.linq

[10] Producer-consumer queue.linq

[20] Two-way signaling and races.linq

[25] Two-way signaling and races - solution.linq

[30] Simulating a ManualResetEvent.linq

[35] Writing a CountdownEvent.linq

[40] Thread rendezvous.linq

/.../[23] Chapter 23 - Parallel Programming/[01] PLINQ/

[01] Calculating prime numbers.linq

[02] Calculating prime numbers - ordered.linq

[05] Parallel spell checker.linq

[06] Parallel spell checker - enhanced.linq

[08] Functional purity.linq

[15] Changing degree of parallelism.linq

[17] Cancellation.linq

[20] Output-side optimization.linq

[22] Input-side optimization - forcing chunk partitioning.linq

[25] Optimizing aggregations - simple use of Aggregate.linq

[27] Optimizing aggregations - seed factory function (contrived).linq

[28] Optimizing aggregations - letter frequencies imperative.linq

[30] Optimizing aggregations - letter frequencies functional.linq

[31] Optimizing aggregations - letter frequencies parallel.linq

/.../[02] The Parallel Class/

[01] Parallel.Invoke.linq

[05] Parallel.For.linq

[06] PLINQ version.linq

[08] Parallel.Foreach - indexed.linq

[10] Parallel Spellchecker with TPL.linq

[12] Breaking early out of loops.linq

[15] Optimization with local values - problem.linq

[17] Optimization with local values - solution.linq

[19] PLINQ version.linq

jaoo.html

lp.html

WordLookup.txt

/.../[03] Task Parallelism/

[01] Creating and starting tasks.linq

[03] Decoupling task creation and execution.linq

[05] Specifying a state object.linq

[06] Putting the state object to better use.linq

[10] Child tasks.linq

[13] Exception-handling child tasks.linq

[15] Canceling tasks.linq

[20] Continuations.linq

[22] Continuations with return values.linq

[23] Continuations and exceptions.linq

[25] Continuations - rethrowing antecedent exceptions.linq

[26] Continuations - exceptions and TaskContinuationOptions.linq

[30] Continuations - extension to swallow exceptions.linq

[31] Continuations and child tasks.linq

[35] Continuations - conditional.linq

[36] Continuations - conditional (solution).linq

[40] Continuations with multiple antecedents.linq

[41] Continuations with multiple antecedents - collating data.linq

[42] Multiple continuations on a single antecedents - collating data.linq

[45] Task Schedulers and UIs.linq

[47] Creating your own Task Factories.linq

/.../[04] Working with AggregateException/

[01] AggregateException.linq

[02] Flatten.linq

[03] Handle.linq

/.../[05] Concurrent Collections/

[01] Producer-Consumer Queue.linq

[02] Producer-Consumer Queue - with Tasks.linq

/.../[06] EXTRA - SpinLock and SpinWait/

[01] SpinLock.linq

[02] SpinWait - SpinUntil.linq

[03] SpinWait - SpinOnce.linq

[05] SpinWait - Lock-free updates with CompareExchange.linq

/.../Compilations and Semantic Models/

Creating a Compilation.linq

Emitting.linq

FileOrder.txt

Querying the semantic model.linq

Renaming a symbol.linq

Semantic model - declared symbol local variable.linq

Semantic model - declared symbols.linq

Semantic model - looking up symbols.linq

Semantic model - symbols.linq

Semantic model - TypeInfo.linq

/.../[27] Chapter 27 - The Roslyn Compiler/

FileOrder.txt

/.../[27] Chapter 27 - The Roslyn Compiler/Syntax Trees/

CSharpSyntaxWalker.linq

FileOrder.txt

Obtaining a syntax tree.linq

Preprocessor directives.linq

Structured trivia - navigating preprocessor directives.linq

Structured trivia.linq

The White Walker.linq

Transforming trees - creating a new tree.linq

Transforming trees - creating nodes and tokens.linq

Transforming trees - CSharpSyntaxRewriter.linq

Transforming trees - handling changes to source code.linq

Transforming trees - visualizing node.linq

Traversing a tree - ClassDeclarationSyntax members.linq

Traversing a tree - descendant tokens.linq

Traversing a tree - finding a method.linq

Traversing a tree - root node.linq

Trivia.linq

Using the LINQPad Syntax Visualizer.linq

/Примеры/

header.xml

IronPython.dll

Microsoft.Dynamic.dll

Microsoft.Scripting.Core.dll

Microsoft.Scripting.dll

Microsoft.Scripting.ExtensionAttribute.dll

Total files 600