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:

• How do faculty and students get access to Microsoft Azure Dev Tools for Teaching (formerly Imagine Premium)?

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:

   

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:
   

   

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:

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.

Visual Studio

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.

.... in progress....

Visual Studio

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-Tutorialkdir $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.

... this section is under constructions...

... this section is under constructions...

Visual Code

Introduction

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

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

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

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

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

Goto MSDoc link: https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/namespaces/

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

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

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

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

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

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

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

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"