Tutorial - MSVS and C#

Spring 2020

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

Updated:  Mon Jan 24 14:09:52 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 listed in the MSDoc's for C# submit the work via Git.
  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 Reading These Instructions

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 prior semester

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" Reality: "? 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

Visual Studio

Time  MSDoc: "? minutes to read" Reality: "? 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.

  1. Goto the MSDoc chapter at link:https://docs.microsoft.com/en-us/visualstudio/get-started/visual-studio-ide?view=vs-2019
  2. 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). 
  3. Work through the Create a program section creating all the code and related files as instructed
  4. Git add and commit the created directories and files with message "-started create-a-program"
  5. Work through the rest of the MSDoc chapter, use good Git practices and commit the code changes as you progress through the chapter.
  6. Do not forget to "Save All" in MSVS
  7. 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" Reality: "? 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" Reality: "? 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" Reality: "? minutes to do"
  1. Goto MSDoc link: https://docs.microsoft.com/en-us/visualstudio/get-started/csharp/tutorial-console?view=vs-2019
  2. 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
  3. Work through sub section Create a project.  Save the files and git add & commit with message "-create a project"
  4. 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"
  5. 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"
  6. Work through sub section Close the app and verify your final code is that describe in section Code complete                             

Visual Code

... this section is under constructions...

Tour of 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"

Goto MSDoc chapter at link 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"

Goto the MSDoc chapter at 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

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

Goto MSDoc 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" Reality: "? minutes to do"

Goto MSDoc 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" Reality: "? minutes to do"

Goto MSDoc 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: "3 minutes to read" Reality: "? minutes to do"

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

  1. In MSVS create new Console solution called Statements and place it your MSVS-CSharp-Tutorial directory.
  2. Read through this chapter.
  3. Copy and paste all the example functions from the chapter into the default project .cs file
    1. Do so one statement example at a time
    2. For each statement example function add a call to that function in Main in order to call the function.
    3. You will need to pass some command line arguments to the program and add code to pass the Main args variable to each of the statement example function calls.
    4. Some examples may require minor modifications to compile due to namespace issues.
    5. Study each code example.   If the statement is something you are unfamiliar with look it up by search the https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/
      (You will answer some questions about what statements are unfamiliar to you in Step #4 below).

  4. Git commit the files with message "-initial statements experiments"
  5. In your file Question.txt answer the following questions:
    1. Statement #1:  Which of the statements are new to you based on your prior programming language experience?
    2. Statement #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?
  6. Git commit the updated files with message "-statements questions"
  7. Modify your .cs file created by adding a few additional uses of the statements that are new to you.
  8. Git commit the updated files with message "-completed Statements Chapter"

Classes and objects

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

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

  1. In MSVS create new Console solution called Classes-and-objects 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.   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]

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

Structs

Time  MSDoc: "2 minutes to read" Reality: "? 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]

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

Arrays

Time  MSDoc: "2 minutes to read" Reality: "? 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.
  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]

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

Interfaces

Time  MSDoc: "2 minutes to read" Reality: "? 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. Arrays #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]

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

Delegates

Time  MSDoc: "2 minutes to read" Reality: "? 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.
  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:  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]

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

Attributes

Time  MSDoc: "2 minutes to read" Reality: "? 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.
  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.
-->