Tutorial - MSVS and C#

Spring 2020

Author: Zachary Wartell
https://webpages.uncc.edu/~zwartell/

Updated:  Wed Feb 2 10:13:55 2022 -0500

Change Log:  [link]



Creative Commons License
"Tutorial - MSVS and C#" by Zachary Justin Wartell is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License.
Git Repo at https://gitlab.com/zwartell/MSVS_CSharp_Tutorial



Compatibility

This page has been tested on Firefox and Chrome. 

Time Estimate:

I estimate this tutorial will take between 10 - 20 hours over the two week assignment period.

Objectives

  1. Read and learn basic subset of the Microsoft Visual Studio 2019 IDE from https://docs.microsoft.com (abbreviated MSDoc's)
  2. Perform tutorial exercises for above and submit work via git.
  3. Read and learn a core subset of C# from MSDoc's (https://docs.microsoft.com).
  4. Perform multiple exercises written in this tutorial that require making minor, trivial modification to code example given inside C# MSDoc's.   The each exercises, is complemented by a 'git commit'
  5. Familiarize yourself with the larger corpus of documentation on MSVS and C# on MSDoc's as reference material for the rest of this course, etc.

Prerequisites

  1. General pre-req's for UNCC CS MS Program
  2. General pre-req's for UNCC ITCS 6125/8125
  3. At least 2 semesters of course work or equivalent with at least one other object-oriented programming language (JavaScript, C++, Java, etc.)
  4. Knowledge and setup of Git as described in course's previous tutorial: https://zwartell.gitlab.io/Git_Tutorial_and_Coding_Standards/Git%20Tutorial.html

Guide To Performing this Tutorial

Presentation Conventions

Note, this section is largely a copy of the "Presentation Conventions" section in all my other tutorials.  If you have grown comfortable with my tutorial's presentation conventions, skip to Section 1.2


Structure of MSDoc's and there use for within this Tutorial Assignment

Like nearly all literature (digital, printed or otherwise) on programming language XYZ, the doc.microsoft.com (hereafter abbreviated as MSDoc's) documentation on on C# is roughly carved up into 3 types of volumes:

Tutorials and "Tours of C#" give a very high-level, short introductions to the language, and programming tools.   Often these tutorials are targeted at individuals with no prior programming experience and hence for the audience this Tutorial Assignment, much, of the material in the C# Tutorials is a re-hash of concepts the reader already knows and probably provide little new knowledge for the reader.

A Programming Guide - The Programming Guide's to a language often presents themselves as being targeted to an audience with no prior programming experience, but in my 40 years of programming, this claim is often just false "feel good" advertising.  Programming Guide's do take the reader step by step through the core language features using many codes example with explanatory notes.   But in reality most programming guides I've encountered are fast paced in introducing new material.   typically the readers who get the most out of a "programming guide" already have programming experience in some other programming language.

A Reference Guide - A Reference guide is generally just an organize list of all the programming languages keywords, operators, statements and control structures, etc. given with minimal examples.   Typically, this is the book a programmer starts to consult after they have mastered the Programming Guide (or perhaps while studying the programming guide).

Internal Language Specification - This is the official document (highly, highly technical) written by the creators and designers of the programming language itself and the languages compiler/interpreter and is used to describe how to build a compiler/interpreter for the language.   Typically it is compiler/interpreter writers who consult this document.   Very experienced programmers (say with years of experience with the given programming language) will eventually find themselves delving into these documents.   (Especially if the said programmer has a proper Computer Science Degree has taken two courses that teach how programming languages are designed and how compilers implemented).

This Tutorial Assignment () pulls subsets of readings from:

Based on the audience (see section Prequisites).   To make this Tutorial Assignment gradable, it contains many, small, typically trivial 'todo' exercises based on the readings.   Each exercise involves generating some bit of code, or answering a short question and git committing the related files to your Tutorial Assignment Git repository.

Git Commit Protocol and Rubric

 In this document's instructions, you are required to make git commits at specific points using specific commit messages.   The git commits are a required part of the assignment.   It also introduces you to good git practices.

  1. For a given exercise that includes specific git commit instructions, if there is not at least 1 git commit message associated with that exercise, 1 point will be subtracted for "poor software development practices" for that exercise.   

    Your commit message need not be a verbatim copy of the commit message given in the exercise’s instructions, but it should be very similar.    (But you can simply cut & paste the messages, so they really should be verbatim).

    The grader will allow for a few of the required commit messages to be missing without incurring a penalty.

    Note: If you accidentally commit with a missing or bad message, you can correct the message using git commit –amend option (see https://git-scm.com/book/en/v2/Git-Basics-Undoing-Things)

    Finally, extra commit's are perfectly fine and common practice, such for fixing other types of coding mistakes, etc.

  2. For exercises that require you modify code already given to you, if only the original example code is committed with no change & there is no evidence from the student (documentation, notes, etc) of trying to solve the exercise, then minimal points will be awarded for that exercise.

Access to Microsoft Visual Studio 2019

If you already have access to a computer with Microsoft Visual Visual Studio 2019 (henceforth abbreviated MSVS) you may not need to perform this section.   However, your MSVS 2019 installation must have installed the components described below.   If you already have MSVS 2019, use the Windows Apps and Features control panel to determine what components of MSVS 2019 are installed.   Read through Section 3.1 to observe what components a you would install if you were installing MSVS 2019 for the first time.    You can then add these components to your MSVS 2019 installation by selecting the Modify option for MSVS 2019 listed under Apps and Features (search for "Visual Studio").

Option I:  Using a MS Windows 10 Computer

If you own, or have access to, Windows 10 computer and have the administrator privileges to install software on that computer then UNCC students can download and install MSVS Enterprise edition for free.   This can be downloaded and install through UNCC's program with Microsoft Azure Dev Tools.   This is accessed as follows:

The product you want to download and install is called "Visual Studio Enterprise 2019".

  1. Download and install MSVS through Azure Dev Tools.
  2. When asked to install various components -- called "Workloads", make the following selection:
    Screen_Capture
  3. The installation process will have several other steps.  Follow them as instructed.
  4. When prompted with setting the initial "Developer Settings" select the ones show below:
    Screen_Capture

Option II:  Using non-MS Windows Computer with Native version of Visual Studio

Circa 2020, Microsoft does have versions of Visual Studio for other operating systems.  But the degree to which these support Unity has not yet been tested by the authors of this tutorial.    Spring 2020 semester students have had success with https://visualstudio.microsoft.com/vs/mac/


  1. If you are considering this option, these versions of Visual Studio for non-Windows OS's typically have a similar install procedure for picking the installed components/workloads and you can mentally translate the procedures in Section 3.1 for you operating system.

Option III:   CCI Open Labs

This section is placeholder for in-progress document development.   The labs only have Visual Studio 2015 as of 1/24/2020.   See recent Announcements in Canvas regarding possibility of using Visual Studio 2015 and status of TSO's making MSVS 2019 available.  I will update this section of this tutorial as soon as I've have confirm the status.

  1. See https://cci.uncc.edu/about-us/technology-resources/woodward-120-143-computer-labs

[Out of Order] Option IV:   Using a non-MS Windows Computer with Remote Desktop to an Cloud Windows 10 VM

Status:  Circa Spring 2022:  Support for this option is deprecated.  It appears the UNCC Azure subscription has changed and deleted all the VM's I created in the prior semester. Curses!

Circa 2/4/2020 - This Option has been successfully used by 2 individuals

This C# tutorial does not use any significant computer graphics.   Under these conditions it is sufficient to use the Remote Desktop Protocol (RDP) to connect to a remote Windows 10 VM on the Azure Cloud.   For this course, a Window 10 VM image on Azure Cloud has been created with the following software installed:

  • Windows 10
  • MSVS 2019 Community Edition
  • git-bash
  • TortoiseGit
  • Dropbox Client

Installing a RDP Client

Microsoft provides an free RDP client for for Windows, MacOS, iOS and Android through the Microsoft Store (https://www.microsoft.com/en-us/store)

Basics instructions on using the RDP client are at this link:

       https://docs.microsoft.com/en-us/learn/modules/create-windows-virtual-machine-in-azure/4-connect-to-a-windows-virtual-machine

The "Open Source" community provides a RDP client for Linux systems.   Instructions to download and install such an RDP client are this link:

      https://remmina.org/jekyll/

On your computer, install the appropriate RDP client.

Starting and Connecting to a Cloud Windows 10 VM    

Overview:  From the Azure Dev Tool Portal ("ADT Portal") you will create a Windows VM that will run in the cloud.   The Windows 10 VM will be based on a VM image created for this course with required software pre-installed.  You will create and start an Azure Cloud VM using the ADT Portal, then you will connect to your cloud Windows 10 VM using your RDP client.

Details:

images/Azure-RDP.png
  1. [PC] Install the appropriate RDP client as discussed in Section 3.2.1
  2. [PC::Browser]: Log in to the Azure Dev Tool Portal ("ADT Portal") with your UNCC credentials. For details see How do faculty and students get access to Microsoft Azure Dev Tools for Teaching (formerly Imagine Premium)?)
  3. [ADT Portal]:  Create a Virtual Machine (VM) in the Azure Cloud using the image UNCC-CS-Grafix-ImageDefinition.  

    To do this watch the first part of video below in item #4.

    (Note: this step, #3, only needs to be done once).

  4. [PC::RDP]:  Connect to your created cloud Virtual Machine (VM) using your Remote Desktop client.   
    To do this continue watching the second part of video below:
  5. [PC::RDP]:   Tutorial Session: Connect to the cloud VM through your RDP client, you can perform all the MSVS and C# exercises and required git commit's.  
  6. [PC::RDP]:   Shutdown:  When you complete a session of work on the tutorial choose "Shutdown" within your RDP client.   This will shutdown your Azure Cloud VM.  This avoids leaving your cloud VM running -- which would uselessly use up your Azure subscription credits.  
    1. Note:  You can double check the status of your cloud VM from the ADT Portal (shown in the video above).   More specifically, from the ADT Portal Home page, click "Virtual Machines" to see the status of your VM's.   More information on the Azure VM life cycle is found at this link https://docs.microsoft.com/en-us/azure/virtual-machines/windows/states-lifecycle.
  7. [PC::RDP]:   Later Tutorial Sessions:  In order to later return to working on the tutorial, you do not need to repeat step #3.   After you created Azure VM in step #3, you only need to re-start the VM from the ADT Portal.   From the ADT Portal Home page, click "Virtual Machines".   Select your VM and then select "Restart".   After the VM status returns to "Running", you can reconnect to it using your RDP client.

    Reminders:
    1. Choose "Shutdown" within your RDP Client to shutdown your Azure Cloud VM to will avoid leaving your Cloud VM running which would uselessly use up your Azure subscription credits.
    2. Step #3 only needs to be done one time to create your Cloud VM from the image UNCC-CS-Grafix-ImageDefinition. Once created, you simply start and stop you Azure Cloud VM through the ADT Portal and then connect to it using your RDP client.

Git Repo Setup

Time  MSDoc: "? minutes to read" Assignment: "? minutes to do"

As your read through various sections of the MSDoc's you will perform various exercises.  You must submit them to various directories inside a single Git repo.

  1. Create a Git repository:

    https://cci-git.uncc.edu/
    your_userid/MSVS-CSharp-Tutorial

    Note: Make sure the repository is Private and give Reporter access to both Dr. Wartell and the TA.
  2. If you have not already, create a subdirectory for your work in this class:
    lucretius@CCIWD-435B-1 ~/
    $mkdir ITCS_VRAR

    lucretius@CCIWD-435B-1 ~/
    $cd ITCS_VRAR

  3. Clone the repo.
    lucretius@CCIWD-435B-1~/ITCS_VRAR/
    $git clone https://cci-git.uncc.edu/your_user_id/MSVS-CSharp-Tutorial.git MSVS-CSharp-Tutorial
    Cloning into'MSVS-CSharp-Tutorial'...
    warning: You appear to have cloned an empty repository.

  4. Inside the MSVS-CSharp-Tutorial directory create a text file called README.md.  Add your name on the first line of the file.  

    Git commit the file with the commit message “initial README.md”
    class"Deliverable">{"system":"git", "operation":"commit"}
  5. Inside the above directory create a second text file called Questions.txt. Add your name on the first line of the file.
    Git commit the file with the commit message “initial Questions.txt”.
    Some of the exercises in this tutorial will involve you answering questions.   You will write you answers in this file.
  6. Copy the file from https://github.com/github/gitignore/blob/master/VisualStudio.gitignore
    to a local file .gitignore in MSVS-CSharp-Tutorial.   (See the https://git-scm.com/book
    for more details on the value and purpose of .gitignore).

    Git add & commit the file.

A C# IDE

This Tutorial Assignment currently assumes all work is done using Visual Studio.    (Instructions for alternative IDE's such as Visual Code may be added in future semesters)

Visual Studio

Time  MSDoc: "? minutes to read" Assignment: "? minutes to do"

In this part you will read MSDoc Welcome to the Visual Studio IDE, perform the exercises it describes and submit the results to Git.

Goto the MSDoc chapter at link:https://docs.microsoft.com/en-us/visualstudio/get-started/visual-studio-ide?view=vs-2019

  1. Read up to section Create a program.  When instructed to pick a location for your Solution place it in your repo directory MSVS-CSharp-Tutorial. (The resulting sub-directory should be called HelloWorld). 
  2. Work through the Create a program section creating all the code and related files as instructed
  3. Git add and commit the created directories and files with message "-started create-a-program"
  4. Work through the rest of the MSDoc chapter, use good Git practices and commit the code changes as you progress through the chapter.
  5. Do not forget to "Save All" in MSVS
  6. Git add and commit the final code with message "-finished create-a-program"

    Note the MSDoc's chapter's See Also section.   These links contain further details that will be useful as you expand your knowledge of MSVS.

Visual Code

.... in progress....

Visual Code, full name "Visual Studio Code", runs on Windows, Mac, and Linux.   It is a different product line that the Community, Profession or Enterprise edition.

https://code.visualstudio.com/

Learn to use the code editor

Visual Studio

Time  MSDoc: "? minutes to read" Assignment: "? minutes to do"

Visual Studio comes in 3 editions.   The Community Edition is available for free to the public, some restrictions on use may apply.  The Profession and Enterprise Editions are for-pay and licensed for commercial use.

For this course I recommend using Community Edition for Windows and Mac users.

In this part you will read Learn to use the code editor, perform the exercises it describes and submit the results to Git.

  1. Goto link:https://docs.microsoft.com/en-us/visualstudio/get-started/csharp/tutorial-editor?view=vs-2019 
  2. Create a sub-directory for the project this section of the MSDoc's has you create:
    $cd MSVS-CSharp-Tutorial
    lucretius@CCIWD-435B-1 ~/ITCS_VRAR/MSVS-CSharp-Tutorial
    kdir
    $mkdir Learn-code-editor; cd Learn-code-editor
  3. Work through the Learn to use the code editor section creating all the code and related files as instructed.
  4. Save the created file to the directory Learn-code-editor
  5. Git add and commit the created file with message "completed Learn-code-editor"

    Note the MSDoc chapters See Also section.   These links contain further details that will be useful as you expand your knowledge of MSVS.

Visual Code

... this section is under constructions...

  1. ...

Learn about projects and solutions

Visual Studio

Time  MSDoc: "12 minutes to read" Assignment: "? minutes to do"

In this part you will read Learn about projects and solutions, perform the exercises it describes and submit the results to Git.

  1. Goto link: https://docs.microsoft.com/en-us/visualstudio/get-started/tutorial-projects-solutions?view=vs-2019
  2. Work through the Learn about projects and solutions, section creating all the code and the QuickDate solution and projects.  
    When instructed to pick a location for you Solution place it in your repo directory MSVS-CSharp-Tutorial
  3. Finish the chapter; Git add and commit the created files with message "completed QuickDate solution"

    Note the MSDoc's See Also section.   These links contain further details that will be useful as you expand your knowledge of MSVS.

Visual Code

... this section is under constructions...

  1. ...

 Create a simple C# console app

Visual Studio

Time  MSDoc: "12 minutes to read" Assignment: "? minutes to do"

Goto MSDoc link: https://docs.microsoft.com/en-us/visualstudio/get-started/csharp/tutorial-console?view=vs-2019
  1. Below you will work through the Create a simple C# console app, section creating all the code and the Calculator app solution and projects.  
    When instructed to pick a location for you Solution place it in your repo directory MSVS-CSharp-Tutorial
  2. Work through sub section Create a project.  Save the files and git add & commit with message "-create a project"
  3. Work through sub section Create the app. 

    For each and every sub-sub section such as Explore integer math, save the files and git add & commit with message that includes the sub-sub section title such as "-explorer integer math"
  4. Work through sub section Debug the app

    For each and every sub-sub section, save the files and git add & commit with message that includes the sub-sub section title such as "-fix the "format" error"
  5. Work through sub section Close the app and verify your final code is that describe in sectionCode complete                             

Visual Code

... this section is under constructions...

C#

Note the MSDoc chapter "Tour of C#" gives instructions on compiling of the code using a standard C# command-line interface (CLI).  This tutorial will give substitute instructions using MSVS 2019 for compiling the example code.

Introduction

Time:  MSDoc  "4 minutes to read"

In the "Tour of C#" goto link: https://docs.microsoft.com/en-us/dotnet/csharp/tour-of-csharp/

  1. Read the entire page.   You do not have to git commit anything for this page.

Program Structure

Time:  MSDoc "3 (?) minutes to read"

In the "Tour of C#" goto link: https://docs.microsoft.com/en-us/dotnet/csharp/toRuur-of-csharp/program-structure

  1. Read through the Program Structure chapter once without attempting to perform the CLI instructions.
  2. Watch the following video that shows how to perform the above CLI steps using MSVS 2019 instead.   Perform these MSVS steps and save your MSVS Solution.
    Note, the text after the video reviews the key steps for future reference.

    Steps Covered in Video:
    1. Create a default "Console" C# Solution
    2. Rename the default Project to an appropriate name for the executable assembly.
    3. Rename the default .cs file as appropriate.
    4. Add a new second Project to the Solution.  Use the default "Console" C# Solution.
    5. Rename the second Project to an appropriate name for the library assembly.
    6. Rename the second Project's default .cs file as appropriate.
    7. Add a Dependency to the first project (the executable) making it depend on the second project (the library)
    8. Adjust the first project (the executable) to be the "Startup" Project for the solution.

      For more details and in depth see the MSDocs such as:
      1. Create solutions and projects
      2. Manage project and solution properties

  3. Git add and commit the files and directories, etc.

Types and Variables (Tour of C#)

Time:  MSDoc "5 minutes to read"; Reality "? minutes to do"

In the "Tour of C#" goto link:  https://docs.microsoft.com/en-us/dotnet/csharp/tour-of-csharp/types-and-variables

Create a sub-directory for the project this section of the MSDoc's has you create:
  1. In MSVS create new Console solution called Types-and-Variables and place it your MSVS-CSharp-Tutorial directory.
  2. Read through the Type and Variables chapter.
  3. Create your own .cs file to code and try out examples of the types and variables discussed in this chapter.
    1. It is recommended to create at least one trivial instances of each variable and type;
    2. Include a box and unbox example.

    Note, You do not have to implement any specific algorithm, etc. but you .cs file should be about 100 lines of code.

  4. Git add and commit the files and directories, etc.

Expressions

Time  MSDoc: "2 minutes to read" Assignment: "? minutes to do"

In the "Tour of C#" goto link: https://docs.microsoft.com/en-us/dotnet/csharp/tour-of-csharp/expressions

  1. Read through this chapter.
  2. Skim over the links to the additional details in particular about overload operators and the complete list of C# operators.
  3. In your file Question.txt answer the following questions:
    1. Expressions #1:  What C# operators are new for you based on your prior programming experience?
    2. Expressions #2: What might some of the advantages of operator overloading be for computer graphics and mathematics?    
    3. Expressions #3: What other languages that you have experience with support operator overloading?
  4. Git commit the updates to Questions.txt with message "-completed Expressions"

Namespaces

Time  MSDoc: "? minutes to read" Assignment: "? minutes to do"

In the "C# Programming Guide" goto link: https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/namespaces/

(Note, we are following the MSDoc's chapter sequence slightly out of order for this chapter.   This is needed before proceeding to the Statements chapter)
  1. Read through this chapter.   You do not have to submit any code, but feel free to experiment as needed.
  2. In your file Question.txt answer the following questions:
    1. Namespaces #1: How do C# namespaces conceptually and syntactically compare to other languages you are familiar with?

Command Line Arguments

(Note, we are following the MSDoc's chapter sequence slightly out of order for this chapter.   This is needed before proceeding to the Statements chapter)

  1. The mechanism C# Console programs pass command-line arguements to Main is similar to C and C++.  If you are not familiar with this concept read https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/main-and-command-args/
  2. When running Console programs MSVS Projects have a property that allows you to pass command line arguments to the program.   See https://docs.microsoft.com/en-us/visualstudio/debugger/project-settings-for-csharp-debug-configurations?view=vs-2019.

Statements

Time  MSDoc: "? total minutes to read" Assignment: "? minutes to do"

In the "C# Programming Guide" go to link: https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/statements-expressions-operators/statements
Detailed reading and Assignment instructions are in the following Assignment sub-sections.

Statements (C# Programming Guide)

Time  MSDoc: "6 minutes to read" Assignment: "? minutes to do"

Goto C# Programming Guide, Statements (C# Programming Guide)

  1. In MSVS create new Console solution called Statements and place it your MSVS-CSharp-Tutorial directory. Read through the MSDoc sections listed below. Copy, Paste and Modify the code snippets for each section into the default .cs file.
  2. Types of statements  -  Just read over this list. Later, you will read an MSDoc section that covers these in more detail

    For items below perform that standard procedure of cut, pasting and modifying the example code into a C# function or class, etc.
  3. Declaration statements
  4. Expression statements
  5. The empty statement
  6. Embedded statements
  7. Nested statement blocks
  8. Unreachable statements
  9. git commit the above with a message "-completed 9.7.1 exercises"

Statements (C# Reference)

Time  MSDoc: "19 minutes to read" Assignment: "? minutes to do"
Goto C# Reference Guide, Statements (C# reference)

For the sections below perform that standard procedure of cut, pasting and modifying the example code into a new C#
file:
  1. Continue using the Console solution Statements create in the prior Assignment section. Read through the MSDoc sections listed below. Copy, Paste and Modify the code snippets for each section into the default .cs file.
  2. Selection Statements
  3. Iteration Statements
  4. Jump Statements
  5. Lock Statements
  6. git commit the above with a message "-completed 9.7.2 exercises"

  7. In your file Question.txt answer the following questions:
    1. Statements #1: Which of the statements are new to you based on your prior programming language experience?
    2. Statements #2: For each of the statement types that is new to you give a brief description of how it works and briefly describe how it is similar and/or different from statements in other languages with which you are familiar?

Types (Fundamentals)

Time  MSDoc (total): minutes to read Assignment: "? minutes to do"

The C# type system

Time  MSDoc: "14 minutes to read" Assignment: "? minutes to do"

Goto MSDoc "Fundamentals" link: The C# type syste

  1. In MSVS create new Console solution called Types-System and place it your MSVS-CSharp-Tutorial directory. Read through the MSDoc sections listed below. Copy, Paste and Modify the code snippets for each section into the default .cs file.
  2. Specifying types in variable declarations
  3. Built-in types
  4. Custom types
  5. The common type system
  6. Types of literal values
  7. Generic types
  8. Implicit types, anonymous types, and nullable value types
  9. Compile-time type and run-time type
  10. git commit with message "-exercises 9.8.1"

Boxing and Unboxing

Time  MSDoc: "5 minutes to read" Assignment: "? minutes to do"

Goto MSDoc link: Boxing and Unboxing

  1. Continue using the your previously In MSVS called Types-System and "copy, paste and modify" the code snippets in the MSDoc sections listed below.
  2. Performance
  3. Boxing
  4. Unboxing
  5. git commit with message "-exercises 9.8.2"

Casting and type conversions

Time  MSDoc: "5 minutes to read" Assignment: "? minutes to do"

Goto MSDoc link: https://docs.microsoft.com/en-us/dotnet/csharp/tour-of-csharp/classes-and-objects

  1. Continue using the your previously In MSVS called Types-System and "copy, paste and modify" the code snippets in the MSDoc sections listed below.
  2. Implicit conversions
  3. Explicit conversions
  4. Type conversion exceptions at run time
  5. git commit with message "-exercises 9.8.3"

How to convert a byte array to an int

Time  MSDoc: "2 minutes to read" Assignment: "? minutes to do"

Goto MSDoc link: How to convert a byte array to an int

  1. Continue using the your previously In MSVS called Types-System and "copy, paste and modify" the code snippets in the MSDoc sections listed below.
  2. Examples
  3. git commit with message "-exercises 9.8.4"

How to convert a string to a number

Time  MSDoc: "4 minutes to read" Assignment: "? minutes to do"

Goto MSDoc link: How to convert a string to a number

  1. Continue using the your previously In MSVS called Types-System and "copy, paste and modify" the code snippets in the MSDoc sections listed below.
  2. Call Parse or TryParse methods
  3. git commit with message "-exercises 9.8.5"

How to convert between hexadecimal strings and numeric types

Time  MSDoc: "3 minutes to read" Assignment: "? minutes to do"

Goto MSDoc link: How to convert between hexadecimal strings and numeric types

  1. Continue using the your previously In MSVS called Types-System and "copy, paste and modify" the code snippets in the MSDoc sections listed below.
  2. Examples
  3. git commit with message "-exercises 9.8.6"

Using type dynamic

Time  MSDoc: "5 minutes to read" Assignment: "? minutes to do"

Goto MSDoc link: Using type dynamic

  1. Continue using the your previously In MSVS called Types-System and "copy, paste and modify" the code snippets in the MSDoc sections listed below.
  2. Conversions
  3. Overload resolution with arguments of type dynamic
  4. Dynamic language runtime
  5. git commit with message "-exercises 9.8.7"

Classes and objects

Time  MSDoc: "23 minutes to read" Assignment: "? minutes to do"

Goto MSDoc link: https://docs.microsoft.com/en-us/dotnet/csharp/tour-of-csharp/classes-and-objects

Unfortunately, MS removed this section recently, sometime after I created this Tutorial Assignment
  1. In MSVS create new Console solution called Classes-and-objects and place it your MSVS-CSharp-Tutorial directory.
  2. Read the MSDoc chapter.
  3. As you read through this chapter copy and paste all the example classes and create at least one instance of each in Main.  
    Following good Git practices, you should make multiple git commits as you progress through the chapter.   Spend some time experimenting with each code example (calling methods, etc.).
  4. In your file Question.txt answer the following questions.   Pick one OOP language you are most familiar with and compare and contrast it's features to C# as detailed below.

    1. Classes #1:  Compare C# kinds of Members to your most familiar OOP language.  Which kinds of C# members are also found in the other language?  Which are only found in C#?  
      [Your answer  should be 3-4 sentences plus two lists]
    2. Classes #2:  Compare C# kinds of accessibility to your most familiar OOP language.  Which of kinds of C# accessibility are found in the other language?  Which are only found in C#?  
      [Your answer  should be 3-4 sentences plus two lists]
    3. Classes #3:  Compare C# kinds of parameters (ref, out, param, etc.) to your most familiar OOP language.  Which of kinds of C# parameters are found in the other language?  Which are only found in C#?  
      [Your answer  should be 3-4 sentences plus two lists]
    4. Classes #4:  Does your most familiar OOP language have a feature similar to C#'s 'static and instance methods'?   Describe one similarity and difference if applicable.  
      [Your answer  should be 3-4 sentences]
    5. Classes #5:  Compare C# 'Virtual, override, and abstract methods' to your most familiar OOP language.  How are these C# feature similar or different than that language? 
      [Your answer  should be 3-4 sentences]
    6. Classes #6: Does your other familiar language support method overloading?   What is an advantage and disadvantage of this language feature?
      [Your answer  should be 3-4 sentences]
    7. Classes #7: Does your other familiar language support C# like properties?   What is an advantage and disadvantage of this language feature?
      [Your answer  should be 3-4 sentences]
    8. Classes #8:  Does your other familiar language support an equivalent to a C# Event as a fundmental language feature?  If not how would that language support the C# Event concept using the language features it has?
      [Your answer  should be 5-6 sentences]
    9. Classes #9:  Does your other familiar language support a feature equivalent to a C# finalizer's?   What is the language feature called?   How is it similar or different than C# finalizer?
      [Your answer  should be 4-5 sentences]

    10. Git commit your updates with the message "-answered classes questions"

Structs

Time  MSDoc: "2 minutes to read" Assignment: "? minutes to do"

Goto MSDoc link: https://docs.microsoft.com/en-us/dotnet/csharp/tour-of-csharp/structs

  1. In MSVS create new Console solution called Structs and place it your MSVS-CSharp-Tutorial directory.
  2. Read this chapter.
  3. As you read through this chapter copy and paste all the example classes and create at least one instance of each in Main.   Following good Git practices, you should make multiple git commits as you progress through the chapter.
  4. In your file Question.txt answer the following questions.   Pick one OOP language you are most familiar with and compare and contrast it's features to C# as detailed below.
    1. Structs #1:  Consider the difference in how a C# struct and a C# class instance is allocated in memory.    Does your familiar language have two different types which are allocated in a similarly different pair of ways?    Or does it support only one?  If one, which allocation strategy is supported?
      [Your answer should be 5-6 sentences]

    2. Git commit your updates with the message "-answered structs questions"

Arrays

Time  MSDoc: "2 minutes to read" Assignment: "? minutes to do"

Goto MSDoc link: https://docs.microsoft.com/en-us/dotnet/csharp/tour-of-csharp/arrays

  1. In MSVS create new Console solution called Arrays and place it your MSVS-CSharp-Tutorial directory.
  2. Read this chapter. Read only the section on Arrays at the above link . While the original link has remained valid, MS greatly rearranged the page containing the overview of Arrays, sometime after I created this Tutorial Assignment
  3. As you read through this chapter copy and paste all the example classes and create at least one instance of each in Main.   Following good Git practices, you should make a few git commits as you progress through the chapter.
  4. In your file Question.txt answer the following questions.   Pick one OOP language you are most familiar with and compare and contrast it's features to C# as detailed below.
    1. Arrays #1: Describe two ways you familiar languages array support is similar or different from that found in C#?
      [Your answer should be 4-5 sentences]

    2. Git commit your updates with the message "-answered arrays questions"

Interfaces

Time  MSDoc: "2 minutes to read" Assignment: "? minutes to do"

Goto MSDoc link: https://docs.microsoft.com/en-us/dotnet/csharp/tour-of-csharp/interfaces

  1. In MSVS create new Console solution called Interfaces and place it your MSVS-CSharp-Tutorial directory.
  2. Read this chapter.
  3. As you read through this chapter copy and paste all the example classes and create at least one instance of each in Main.   Following good Git practices, you should make a few git commits as you progress through the chapter.
  4. In your file Question.txt answer the following questions.   Pick one OOP language you are most familiar with and compare and contrast it's features to C# as detailed below.
    1. Interfaces #1: Does your familiar OOP language have a specific interface construct?   If yes, how similar or different is it to C#?   If not, what language feature would you use to mimic a C# interface?
      [Your answer should be 4-5 sentences]

    2. Git commit your updates with the message "-answered interfaces questions"

Delegates

Time  MSDoc: "2 minutes to read" Assignment: "? minutes to do"

Goto MSDoc link: https://docs.microsoft.com/en-us/dotnet/csharp/tour-of-csharp/delegates

  1. In MSVS create new Console solution called Delegates and place it your MSVS-CSharp-Tutorial directory.
  2. Read this chapter. Read only the section on Delegates at the above link. While the original link has remained valid, MS greatly rearranged the page containing the overview of Arrays, sometime after I created this Tutorial Assignment
  3. As you read through this chapter copy and paste all the example classes and create at least one instance of each in Main.   Following good Git practices, you should make a few git commits as you progress through the chapter.
  4. In your file Question.txt answer the following questions.   Pick one OOP language you are most familiar with and compare and contrast it's features to C# as detailed below.
    1. Delegates #1: Does your familiar OOP language have a specific delegates construct?   If yes, how similar or different is it to C#?   If not, what language feature would you use to mimic a C# delegate?
      [Your answer should be 6-7 sentences]

    2. Git commit your updates with the message "-answered delegates questions"

Attributes

Time  MSDoc: "2 minutes to read" Assignment: "? minutes to do"

Goto MSDoc link: https://docs.microsoft.com/en-us/dotnet/csharp/tour-of-csharp/attributes

  1. In MSVS create new Console solution called Attributes and place it your MSVS-CSharp-Tutorial directory.
  2. Read this chapter. Read only the section on Attributes at the above link. While the original link has remained valid, MS greatly rearranged the page containing the overview of Arrays, sometime after I created this Tutorial Assignment
  3. As you read through this chapter copy and paste all the example classes and create at least one instance of each in Main.   Following good Git practices, you should make a few git commits as you progress through the chapter.
  4. In your file Question.txt answer the following questions.   Pick one OOP language you are most familiar with and compare and contrast it's features to C# as detailed below.
    1. Attributes #1: Does your familiar OOP language have a specific attribute construct?   If yes, how similar or different is it to C#?   If not, what language feature would you use to mimic a C# attribute as best as possible?]
      [Your answer should be 5-6 sentences]
    2. Git commit your updates with the message "-answered attributes questions"

Rubric




Section Item Category Link Check Points Awarded Comments

Academic Integrity

See the course syllabus regarding partial credit and the late penalty policy.  

This is an individual student project.   Each student should be writing and submitting their own code. 

Students can discuss general aspects of the various API's and tools with each other and this is strongly encouraged.   Discussing algorithm's at the pseudo-code level is also acceptable.  

However, it is not permissible:

If you have questions about whether using a particular resource is acceptable or not, email the TA and/or Professor.