Author: admin

C# Guide from MS index annotated with video links

I am freshening up on C#. I copied C# guide index from https://docs.microsoft.com/en-us/dotnet/csharp/ and in the process of linking to videos to help me review. Below I share work in process.

  1. C# documentation Get started Introduction Types

  2. Program building blocks Major language areas Tutorials

    1. Choose your first lesson Browser based
      tutorials Hello world
    2. Numbers in C# Branches and loops List collections
    3. Work in your local environment Set up your
      environment Numbers in C#
    4. Branches and loops List collections

  3. Fundamentals Program structure
    Overview

    1. Main method
      https://www.youtube.com/watch?v=5Xd1x0Iivdk&t=143s (OKAY)
      https://www.youtube.com/watch?v=xOuI0n0O324 (BAD)
      https://www.youtube.com/watch?v=hiQcIgLAJnk (BAD)

    2. Top-level statements Type system Overview
      Namespaces
      https://www.youtube.com/watch?v=yZGSOafui44&t=149s (BAD)

    3. Classes Records Interfaces
      https://www.youtube.com/watch?v=9Byvwa9yF-I (GOOD)

    4. Generics
      https://www.youtube.com/watch?v=l6s7AvZx5j8&t=352s (GOOD; LONG)
      https://www.youtube.com/watch?v=7VlykMssZzk&t=88s (GOOD)
      https://www.youtube.com/watch?v=ZrjCG0Fu5Ew

    5. Anonymous Types
      https://www.youtube.com/watch?v=u8C9iO_4yIQ&t=21s
      https://www.youtube.com/watch?v=q1AUv47Eq28
      https://www.youtube.com/watch?v=bT1MRNwI5xw

  4. Object Oriented programming Overview

    1. Objects Inheritance Polymorphism
      https://www.youtube.com/watch?v=CClziU97Xeg&t=28s
      https://www.youtube.com/watch?v=ZzVxgJmLAsE&t=60s

  5. Functional techniques Pattern matching Discards

    1. Deconstructing tuples and other types Exceptions
      and errors
      https://www.youtube.com/watch?v=x3At5Pq2__I&t=46s (long; high quality)
    2. Overview
      https://www.youtube.com/watch?v=uyMoRcgI9qQ
      https://www.youtube.com/watch?v=9lvx6mzCAE4
    3. Using exceptions Exception handling
    4. Creating and throwing exceptions Compiler-generated exceptions Coding style
    5. Identifier names
    6. C# coding conventions Tutorials
    7. How to display command-line arguments Introduction to classes
    8. Object-Oriented C# Inheritance in C# and .NET Converting types
    9. Build data-driven algorithms with pattern matching How to handle an exception
      using try-catch
    10. How to execute cleanup code using finally
      What's new in C#

  6. C# 0. 7. C# 0. >

  7. C# 0.- 3. 9. Compiler breaking changes C# Version History Relationships to
    .NET library Version compatibility Tutorials

    1. Explore record types Explore top level statements
      Explore patterns in objects
    2. Safely update interfaces with default
      interface methods Create mixin functionality with default interface methods Explore
      indexes and ranges
    3. Work with nullable reference types Upgrade
      an app to nullable reference types
    4. Generate and consume asynchronous
      streams Tutorials

  8. Explore string interpolation - interactive

  9. Explore string interpolation - in your environment Advanced scenarios
    for string Interpolation Console Application

  10. REST Client Work with LINQ Use Attributes

  11. C# concepts

  12. Nullable reference types

  13. Choose a strategy for enabling nullable
    reference types Methods

  14. Properties Indexers Iterators

  15. Delegates & events Introduction to Delegates

    1. System.Delegate and the delegate keyword
    2. Strongly Typed Delegates Common Patterns
      for Delegates Introduction to events
    3. Standard .NET event patterns The Updated
      .NET Event Pattern
    4. Distinguishing Delegates and Events Language-Integrated Query (LINQ) Overview of LINQ
    5. Query expression basics LINQ in C#
    6. Write LINQ queries in C# Query a
      collection of objects Return a query from a method
    7. Store the results of a query in memory Group
      query results
    8. Create a nested group
    9. Perform a subquery on a grouping operation
      Group results by contiguous keys
    10. Dynamically specify predicate filters
      at runtime Perform inner joins
    11. Perform grouped joins Perform left outer
      joins
    12. Order the results of a join clause Join
      by using composite keys Perform custom join operations
    13. Handle null values in query expressions
      Handle exceptions in query expressions Write safe, efficient code

  16. Expression trees

    1. Introduction to expression trees Expression
      Trees Explained

    2. Framework Types Supporting Expression Trees
    3. Executing Expressions Interpreting Expressions
      Building Expressions Translating Expressions Summary

  17. Native interoperability Documenting your
    code Versioning

  18. How-to C# articles Article index

  19. Split strings into substrings Concatenate strings Search strings

  20. Modify string contents Compare strings

  21. How to catch a non-CLS exception

  22. The .NET Compiler Platform SDK (Roslyn APIs)

  23. The .NET Compiler Platform SDK (Roslyn APIs) overview Understand the compiler API model

  24. Work with syntax Work with semantics

  25. Work with a workspace

  26. Explore code with the syntax visualizer
    Quick starts

    1. Syntax analysis Semantic analysis Syntax
      Transformation Tutorials
    2. Build your first analyzer and code fix C#
      programming guide

  27. Overview

  28. Programming concepts

    1. Overview
    2. Asynchronous programming Overview
    3. Asynchronous programming scenarios Task
      asynchronous programming model Async return types
    4. Cancel tasks
    5. Cancel a list of tasks
    6. Cancel tasks after a period of time
    7. Process asynchronous tasks as they
      complete Asynchronous file access
    8. Attributes Overview
    9. Creating Custom Attributes
    10. Accessing Attributes by Using Reflection
    11. How to create a C/C++ union by using attributes
      Collections
    12. Covariance and contravariance Overview
    13. Variance in Generic Interfaces Create Variant
      Generic Interfaces
    14. Use Variance in Interfaces for Generic Collections
      Variance in Delegates
    15. Use Variance in Delegates
    16. Use Variance for Func and Action Generic
      Delegates Expression trees
    17. Overview
    18. How to execute expression trees How to modify
      expression trees
    19. How to use expression trees to build dynamic
      queries Debugging Expression Trees in Visual Studio

    20. DebugView Syntax
    21. Iterators
    22. Language-Integrated Query (LINQ) Overview
    23. Getting Started with LINQ in C# Introduction
      to LINQ Queries LINQ and Generic Types Basic LINQ
      Query Operations
    24. Data Transformations with LINQ
    25. Type Relationships in LINQ Query Operations
      Query Syntax and Method Syntax in LINQ
    26. C# Features That Support LINQ Walkthrough:
      Writing Queries in C# (LINQ) Standard Query Operators Overview
      Overview
    27. Query Expression Syntax for Standard Query
      Operators Classification of Standard Query Operators by Manner of Execution Sorting
      Data
    28. Set Operations Filtering Data Quantifier
      Operations Projection Operations Partitioning Data
    29. Join Operations Grouping Data Generation
      Operations Equality Operations Element Operations Converting Data Types
    30. Concatenation Operations Aggregation Operations
      LINQ to Objects

    31. Overview
    32. LINQ and Strings How to articles
    33. How to count occurrences of a word in a
      string (LINQ)
    34. How to query for sentences that contain
      a specified set of words (LINQ) How to query for characters in a string
      (LINQ)
    35. How to combine LINQ queries with
      regular expressions How to find the set difference between two lists (LINQ) How to sort or filter text data by any word or field (LINQ) How to reorder the fields of a delimited file (LINQ)
    36. How to combine and compare string collections
      (LINQ)
    37. How to populate object collections from
      multiple sources (LINQ) How to split a file into many files
      by using groups (LINQ)
    38. How to join content from dissimilar files
      (LINQ)
      16.. How to compute column values in a CSV text file (LINQ) LINQ and Reflection
    39. How to query an assembly's metadata with
      Reflection (LINQ) LINQ and File Directories
    40. Overview
    41. How to query for files with a specified
      attribute or name How to group files by extension (LINQ)
    42. How to query for the total number of bytes
      in a set of folders (LINQ) How to compare the contents of two
      folders (LINQ)
    43. How to query for the largest file or files
      in a directory tree (LINQ) How to query for duplicate files in
      a directory tree (LINQ)
    44. How to query the contents of files in a
      folder (LINQ) How to query an ArrayList with LINQ
    45. How to add custom methods for LINQ
      queries LINQ to ADO.NET (Portal
      Page)
    46. Enabling a Data Source for LINQ Querying
      Visual Studio IDE and Tools Support for LINQ Reflection

    47. Serialization (C#)
    48. Overview
    49. How to write object data to an XML file
      How to read object data from an XML file
    50. Walkthrough: Persisting an Object in Visual
      Studio Statements, expressions, and operators
    51. Overview Statements
    52. Expression-bodied members Anonymous functions Overview
    53. How to use lambda expressions in a query
      Equality and equality comparisons
    54. Equality comparisons
    55. How to define value equality for a type
      How to test for reference equality (identity)

  29. Types

    1. Casting and Type Conversions Boxing and
      Unboxing
    2. How to convert a byte array to an int How
      to convert a string to a number
    3. How to convert between hexadecimal strings
      and numeric types Using Type dynamic
    4. Walkthrough: Creating and Using Dynamic
      Objects (C# and Visual Basic) Classes, Structs, and Records
    5. Polymorphism
    6. Versioning with the Override and New Keywords
      Knowing When to Use Override and New Keywords How to override the ToString method
    7. Members
    8. Members overview
    9. Abstract and Sealed Classes and Class Members
    10. Static Classes and Static Class Members
    11. Access Modifiers Fields
    12. Constants
    13. How to define abstract properties How
      to define constants in C# Properties
    14. Properties overview Using Properties Interface
      Properties
    15. Restricting Accessor Accessibility
    16. How to declare and use read write
      properties Auto-Implemented
      Properties
    17. How to implement a lightweight class
      with auto-implemented
      properties Methods
    18. Methods overview Local functions
    19. Ref returns and ref locals Parameters
    20. Passing parameters
    21. Passing Value-Type Parameters Passing Reference-Type Parameters
    22. How to know the difference between passing
      a struct and passing a class reference to a method
    23. Implicitly Typed Local Variables
    24. How to use implicitly typed local variables
      and arrays in a query expression Extension Methods
    25. How to implement and call a custom extension
      method How to create a new method for an enumeration Named and Optional
      Arguments
    26. How to use named and optional arguments
      in Office programming Constructors
    27. Constructors overview
    28. Using Constructors
    29. Instance Constructors Private Constructors
      Static Constructors
    30. How to write a copy constructor Finalizers
    31. Object and Collection Initializers
    32. How to initialize objects by using an
      object initializer How to initialize a dictionary with a collection initializer
      Nested Types
    33. Partial Classes and Methods
    34. How to return subsets of element properties
      in a query Interfaces
    35. Explicit Interface Implementation
    36. How to explicitly implement interface members
    37. How to explicitly implement members of two
      interfaces Delegates
    38. Overview
    39. Using Delegates
    40. Delegates with Named vs. Anonymous Methods
    41. How to combine delegates (Multicast Delegates) (C# Programming Guide) How to declare, instantiate, and use
      a delegate

  30. Arrays Overview

    1. Single-Dimensional Arrays Multidimensional Arrays Jagged Arrays
    2. Using foreach with Arrays Passing
      Arrays as Arguments Implicitly Typed Arrays Strings
    3. Programming with strings
    4. How to determine whether a string represents
      a numeric value

  31. Indexers Overview Using Indexers

    1. Indexers in Interfaces
    2. Comparison Between Properties and
      Indexers Events
    3. Overview
    4. How to subscribe to and unsubscribe from
      events
    5. How to publish events that conform to
      .NET Guidelines How to raise base class events in derived classes
    6. How to implement interface events
    7. How to implement custom event accessors
      Generics
    8. Generic Type Parameters Constraints on Type
      Parameters Generic Classes
    9. Generic Interfaces Generic Methods Generics
      and Arrays Generic Delegates
    10. Differences Between C++ Templates and
      C# Generics Generics in the Run Time
    11. Generics and Reflection Generics and
      Attributes Namespaces
    12. Using namespaces
    13. How to use the My namespace XML
      documentation comments Overview
    14. Recommended tags for documentation
      comments Processing the XML file

    15. Delimiters for documentation tags
    16. How to use the XML documentation features
      Documentation tag reference
    17. <c>
    18. <code>
    19. cref attribute
    20. <example>
    21. <exception>
    22. <include>
    23. <inheritdoc>
    24. <list>
    25. <para>
    26. <param>
    27. <paramref>
    28. <permission>
    29. <remarks>
    30. <returns>
    31. <see>
    32. <seealso>
    33. <summary>
    34. <typeparam>
    35. <typeparamref>
    36. <value>

  32. File System and the Registry Overview

    1. How to iterate through a directory tree
    2. How to get information about files, folders,
      and drives How to create a file or folder
    3. How to copy, delete, and move files and
      folders
    4. How to provide a progress dialog box
      for file operations How to write to a text file
    5. How to read From a text file
    6. How to read a text file one line at a time
    7. How to create a key in the registry Interoperability
    8. .NET Interoperability Interoperability Overview
    9. How to access Office interop objects by
      using C# features How to use indexed properties in COM interop programming How to
      use platform invoke to play a WAV file
    10. Walkthrough: Office Programming (C# and Visual Basic) Example COM Class

  33. Language reference Overview

  34. Configure language version Types

    1. Value types Overview
    2. Integral numeric types
    3. nint and nuint native integer types Floating-point numeric types
    4. Built-in numeric conversions bool
    5. char
    6. Enumeration types Structure types Tuple types Nullable value types
    7. Reference types
    8. Features of reference types Built-in reference types record
    9. class interface
    10. Nullable reference types
    11. void var
    12. Built-in types Unmanaged types Default values Keywords Overview
    13. Modifiers
    14. Access Modifiers Quick reference Accessibility
      Levels Accessibility Domain
    15. Restrictions on Using Accessibility Levels
      internal
    16. private protected
      public
    17. protected internal private protected abstract
    18. async const event extern
    19. in (generic modifier)
      new (member modifier) out (generic modifier)
      override
    20. readonly sealed static
    21. unsafe
    22. virtual volatile
    23. Statement Keywords Statement categories
      Selection Statements if-else
    24. switch
    25. Jump Statements break
    26. continue goto return
    27. Exception Handling Statements throw
    28. try-catch try-finally
    29. try-catch-finally
      Checked and Unchecked Overview
    30. checked unchecked fixed Statement lock Statement
    31. Method Parameters Passing parameters params
    32. in (Parameter Modifier) ref
    33. out (Parameter Modifier) Namespace Keywords namespace
    34. using
    35. Contexts for using using Directive using static Directive using Statement
    36. extern alias
    37. Generic Type Constraint Keywords new constraint
    38. where
    39. Access Keywords base
    40. this
    41. Literal Keywords null
    42. true and false default
    43. Contextual Keywords Quick reference add
    44. get init
    45. partial (Type) partial
      (Method) remove
    46. set
    47. when (filter condition)
      value
    48. yield
    49. Query Keywords Quick reference from clause
      where clause

    50. select clause
    51. group clause into
    52. orderby clause join clause
    53. let clause ascending descending on
    54. equals by
    55. in

  35. Operators and expressions Overview

    1. Arithmetic operators Boolean logical
      operators Bitwise and shift operators Equality operators Comparison operators
    2. Member access operators and expressions
      Type-testing operators and
      cast expression User-defined conversion
      operators
    3. Pointer-related operators Assignment operators Lambda expressions Patterns
      • and += operators
      1. and -= operators
    6. ?: operator
    7. ! (null-forgiving) operator
    8. ?? and ??= operators
      1. operator
    10. :: operator
    11. await operator
    12. default value expressions delegate operator
    13. is operator
      nameof expression new operator sizeof operator
    14. stackalloc expression switch expression
    15. true and false operators with
      expression Operator overloading

  36. Statements

    1. Iteration statements Special characters
      Overview
    2. $ -- string interpolation @ -- verbatim identifier

  37. Attributes read by the compiler Global attributes

    1. Caller information Nullable static analysis
      Miscellaneous

  38. Unsafe code and pointers Preprocessor directives
    Compiler options

    1. How to set options Language options Output
      options Input options
    2. Error and warning options
    3. Code generation options
    4. Security options Resources options Miscellaneous
      options Advanced options Compiler messages

  39. C# 0. draft specification C# 0. - 0. proposals