Studio’s Developer Command Prompt source codes C#...

Visual C# - Penn P. Wu, PhD. 1

Lecture #1 Introducing Visual C#

Introduction to

the C#

Language and

the .NET

Framework

According to Microsoft, C# (pronounced “C sharp”) is a programming language that is

designed for building a variety of applications that run on the .NET Framework. C# is simple,

powerful, type-safe, and object-oriented. It provides many innovations to enable rapid

application development while retaining the expressiveness and elegance of C-style languages.

C# was developed around 2000 by Microsoft within its .NET initiative and later approved as a

standard by Ecma and ISO. Microsoft’s Visual Studio supports Visual C# with a full-featured

code editor, compiler, project templates, designers, code wizards, a powerful and easy-to-use

debugger, and other tools.

C# programs run on the .NET Framework, which is an integral component of Windows that

includes a virtual execution system called the common language runtime (CLR) and a unified

set of class libraries. The CLR is Microsoft’s implementation of the common language

infrastructure (CLI). It is an international standard that is the basis for creating execution and

development environments in which languages and libraries work together seamlessly.

Visual Studio 2017 and the

Developer

Command

Prompt

Visual Studio 2017 is a rich, integrated development environment (IDE) for creating stunning applications for Windows, Android, and iOS, as well as modern web applications and cloud

services. It is a full-featured and extensible toolkit for developers to build Windows-based

applications. As of January 2019, Microsoft says “Visual Studio Community is free for

individual developers, open source projects, academic research, training, education, and small

professional teams”. Students can, thus, download it from the

https://www.visualstudio.com/downloads/ website.

The Developer Command Prompt for Visual Studio automatically sets the environment

variables that enable developers to easily use the .NET Framework tools to hand-code

applications. The Developer Command Prompt is installed with full or community editions of

Visual Studio, although it is not installed with the Express versions of Visual Studio.

Throughout this class, students will learn to hand-code C# programs and compile them with

Visual Studio’s Developer Command Prompt. Later lectures will discuss about the C#

programming basics in more detail.

Creating C#

source files

C# programmers write text-based source codes similar to the following example using any text

editor such as the Microsoft Notepad, and then compile the source codes to object codes with

C# compiler. The term “text-based” means the content consists of only a combination of

English characters (alphabet, numerals, and symbols).

namespace Samples

{

class Welcome

{

static void Main(string[] args)

{

System.Console.Write("Welcome to CIS218 Visual C#!");

}

}

}

A “compiler” is a special program that reads statements written in the C# programming

language and converts the “text-based” content into the binary “machine code” for the computer’s processor to read and execute. During compilation the compiler transforms source

code into pieces of “object codes”. Each piece of object codes cannot be executed. The


compiler must further assemble object codes into one single executable application with

the .exe extension in order to be executable in the Windows environment. The Windows

operating systems will execute the completed .exe applications. By the way, each object code is

known as an “assembly” in the .Net platform. The following figure illustrates how the C#

compiler converts a C# source code into an .exe application.

C# source codes must be saved as text file and adopt the “.cs” file extension, such as

“Welcome.cs”. Throughout this course, the instructor recommends students to use Microsoft

Notepad as editor to write all the source codes. The following figure illustrates how to use

Notepad to save the source code in a file named “Welcom.cs”, which will be saved as a generic

text file. In a Notepad window, click File and then “Save As...” can lead to the following figure.

Always make sure to the “Save as type:” is changed to “All Files (*.*); otherwise, Notepad

might automatically add “.txt” to the file name (“Welcome.cs.txt”).

Another way to use Notepad to create a source file named “Welcome.cs” is by typing

notepad.exe Welcome.cs (or notepad Welcome.cs) and pressing [Enter] in the

Developer Command Prompt.

C:\Program Files\Microsoft Visual

Studio\2017\Community>notepad.exe Welcome.cs

In this course, the instructor recommends students to create a “C:\cis218” directory and save

all the Visual C# source codes in that directory. The Developer Command Prompt supports the

MS-DOS commands, such as “md” and “cd”. The “md” command can create a new directory,

while the “cd” command can change from current directory to the specified directory. To create

a new directory named “cis218” under the “root” directory of the “C” drive, type md

c:\cis218 and press [Enter].

C:\Program Files\Microsoft Visual Studio\2017\Community>md

C:\cis218

To change to that directory, type cd c:\cis218 and press [Enter].

C:\Program Files\Microsoft Visual Studio\2017\Community>cd

C:\cis218

C:\cis218>

Throughout this course, students should learn to create a source file in the Developer Command

Prompt by typing notepad.exe Welcome.cs (or simply notepad Welcome.cs) and press

[Enter] in the prompt. Click “Yes” after.

C:\cis218>notepad Welcome.cs

In a Windows machine with Visual Studio installed successfully, programmers can invoke the

C# compiler by typing its name, csc.exe, followed by options and the file name of source code

class Welcome

{

}

Object code 1

Object code 2

Object code n

10011001100111

10001111001111

00000011110010

000111110011


on the Developer Command Prompt. The following demonstrates how to compile the source

code “Welcome.cs” to a self-executable program “Welcome.exe” by typing csc.exe

Welcome.cs (or simply csc Welcome.cs) and press [Enter].

C:\cis218>csc Welcome.cs

Microsoft (R) Visual C# Compiler version 1.0.0.50618

Copyright (C) Microsoft Corporation. All rights reserved.

During the compilation, the compiler creates a new file, Welcome.exe, which is a self-

executable application. One way to check its existence is to type dir Welcome.* and press

[Enter] in the prompt. The following shows how the output could be if Welcome.exe is created

successfully. It is necessary to note the source code will stay the way it is, which means no

change is made to its content, even after compilation.

C:\cis218>dir Welcome.*

Volume in drive C has no label.

Volume Serial Number is 84AF-8E2B

Directory of C:\cis218

01/01/2019 10:05 PM 875 Welcome.cs

01/01/2019 10.05 PM 13,824 Welcome.exe

After compilation, type Welcome.exe (or simply Welcome) and press [Enter] to run the .exe

application. C:\cis218>Welcome.exe

The above code, again, is a concole application. In Microsoft’s term, this Welcome.exe

program’s “Output File Format” is set to be “DOS-based” which means it must be executed in a

Command Prompt (or a DOS envrionment). This kind of program will not work in Windows

desktop envrionment. The above console application will generate the following output.

C:\cis218>

Welcome to CIS218 Visual C#!

A later section will discuss the differences between a console and a GUI application. In the next

section, the instruction will temporarily jump off the topic to explain what the above source

code includes and what its statements mean.

It is necessary to note that C# compiler is installed only when a version of Visual Studio (such

as Visual Studio Community) is installed to a Windows machine. Without a successful

installation of Visual Studio version, the above C# source code cannot be compiled into an .exe

application. With the Visual Studio installed in a Windows machine, programmers can launch the Developer Command Prompt (not the regular Window Command Prompt). Windows 10

users need to open the Start menu, press the Windows logo key , and then enter dev on the

Start menu to bring a list of installed apps, choose the Developer Command Prompt. By

default, the Developer Command Prompt displays the following path after being launched,

where “X” is the drive name (such as “C”).

X:\Program Files\Microsoft Visual Studio\2017\Community>

Basic structure

of a C#

program

In the following sample code, “Samples” is a user-declared namespace. In C#, “namespace” is

used to control the scope of class and method names.

namespace Samples

{

class Welcome


{


{


}

}

}

One namespace can contain multiple classes. However, user-declared namespaces are only

useful in larger programming projects. In a small-scale coding project, with or without

declaring a namespace does not matter a remarkable difference. The following table compares

two C# codes. They produce the same results, yet one has declared namespace while the other

does not.

With namespace Samples

{

class Welcome

{


{


}

}

}

Without class Welcome

{


{


}

}

C# allows programmers to split a class definition. When working on large projects, splitting a

class over separate files enables programmers to add codes without having to recreate the

source file. Visual Studio uses this approach when it creates Windows Forms, Web service

wrapper code, and so on. Another benefit to split a class definition is that multiple programmers to work on it at the same time. By the way, after splitting, each “partial class” is known as a

“part”. All the parts must use the partial keyword. All the parts must be available at compile

time to form the final type. All the parts must have the same accessibility, such as public,

private, and so on.

The following example explains how to use the partial keyword modifier to split a class

definition. The “Sample” class is split into two “partial classes”.

using System;

using System.Windows.Forms;

partial class Sample

{

static String str = "Hello World!";

}


{


{

MessageBox.Show(str); // a message box

}


}

Throughout this course, the focus of instructional contents is to help students build a solid hand-

coding foundation using C#; therefore, the instructor frequently chooses not to add user-

declared namespaces. Most the future sample codes will not contain user-declared namespaces.

Every self-executable C# program must have one “programmer-defined” class. In the above

example, “Welcome” is the programmer-defined class. In C#, such class defines an entity

which describes the behavior of its members. The only member in the “Welcome” class is the

Main() method. A method of the class is a set of statements to be executed to generate desired

results.

Every C# program must have at least one “class” that hosts the Main() method to describe to

the C# compiler where the application should start with. The Main() method in the class then

serves as the “entry point” of the application. The term “entry point” indicates that all

statements in the Main() method are the first statements to be executed when the application is

launched.

A complicated C# program may contain several “classes”; however, only one of these classes is

allowed to host the Main() method. The one and the only one class that hosts the Main() method

is known as the “main class”. Each C# “class” is defined by using the class keyword followed

by the class identifier, as demonstrated below in which “ProgramEntry” is the identifier and the

class is said to be the “ProgramEntry” class. Inside the “ProgramEntry” class, there is a Main()

method.

namespace Samples

{

class ProgramEntry

{


{

}

}

}

The signature of the Main() method is static void Main(string[] args). The

parameter, string[] args, in the Main() method can pass arguments generated by the

command-line interface (console) to the Main() method when executing the console application

in the command-line interface.

Interestingly, GUI and Windows form applications typically run in the Windows desktop

environment which does not generate such command-line arguments. Therefore, the string[]

args parament is not required for source codes of GUI and Windows form applications. The

signature of them is thus: static void Main(). A later section will discuss this topic in

detail.

According to Microsoft’s C# Reference, the Main() method must be declare with the static modifier. In C#, any class member declared a static member belongs to the class itself;

therefore, static members cannot be referenced through an instance. A static method means the

method can only have one version regardless of its type and cannot be overridden. Basically, it

means no change is allowed. While C# programs can have many methods and programmers can

place these methods in any order in the source code, the Main() method is always the method

that starts the program and it must be set to static.



Again, it is necessary to note that the String[] args parameter is only required for console

application. Throughout the course, students will write GUI applications with the following

version.

static void Main()

The Main() method in C# can also be declared with public access modifier, as shown below. In this case, “public” specifies that the Main() method can be called from anywhere of the

program, “static” means that Main() does not belong to a specific object, “void” means the

Main() does not return any value, and args is a collection of string arguments generated by the

console command-line interface (e.g. the Command Prompt).

public static void Main(string[] args) { }

All the basic input, processing, and output (the so-called “IPO”) activities can be managed to

happen inside the Main() method. In the following example, the instructor uses the Write()

method, which is one of the output methods of the Console class of the System namespace in

the run-time library, to display a string text on the standard output device (typically the screen).

In plain English, the following program displays a message on the prompt. The System

namespace contains fundamental classes and base classes that define commonly-used value and

reference data types, events and event handlers, interfaces, attributes, and processing

exceptions. The Console class provides standard input, output, and error streams for console

applications.

namespace Samples

{

class ExampleEntry

{


{


}

}

}

The C# language core provides many namespace, such as the System namespace. Each

namespace contains fundamental classes and base classes that define commonly-used value and

reference data types, events and event handlers, interfaces, attributes, and processing

exceptions. A “namespace” often consists of several pre-created “classes” of the .NET

Framework as the run-time library. These “classese” are created by the programers who created

the C# language core. There are two different ways to use namespaces in C#: (a) the use of fully

qualified name and (b) the use of “using” directives.

In the following, each time when the WriteLine() method is called, its fully qualified name

(System.Console.WriteLine) must be used; therefore, the following example requires

programmers to specify the same fully qualified name every time when the WriteLine method is

used. By the way, the WriteLine() displays a string text followed by a new line while Write()

method display a string without adding a new line.

namespace Samples

{

class ExampleEntry


{


{

System.Console.WriteLine("Welcome to CIS218 Visual C#!");

System.Console.WriteLine("You should have fun.");

System.Console.WriteLine("Create your own applications.");

}

}

}

If the use of fully qualified name is redundant, programmers can choose to import a given

namespace with the “using” directive. The following illustrates how to import the System

namespace. Every C# statement must end with a semiclon (;), which indicates the end of line.

using System;

With the namesapce being imported, “classes” provided by the namesapce can be referenced

and members of these “classes” can be use as a tool. The following statement demonstrates how

to use the Write() method of the Console class. By the way, there is a dot (.) operator, known as

“member of” operator, between a class identifier and the method.

using System;

namespace Samples

{

class ExampleEntry

{


{

Console.WriteLine("Welcome to CIS218 Visual C#!");

Console.WriteLine("You should have fun.");

Console.WriteLine("Create your own applications.");

}

}

}

In the above console application code, the Main() method contains a parameter, args, which is

an array of the string type. The following example demonstrates how to print out the command

line arguments using a foreach loop. A later lecture will discuss the foreach structure in details.

//Filename: ProgramEntry.cs

using System;

namespace Samples

{

class ExampleEntry

{


{

foreach (string s in args)

{

Console.WriteLine(s);


}

}

}

}

After successful compilation, the following demonstrates how to test the above program.

C:\cis218>ProgramEntry.exe anita catherine lucy

anita

catherine

lucy

Apparently, by importing the System namespace with the “using” directive at the beginning of

the program; every member of the System class can be directly called for use without the need

to specify the fully qualifiedg name (e.g. System.Console.Write()). Throughout this

course, the instructor will adopt this short-hand way to eliminate the use of fully qualified

names.

C# programs heavily rely on these input/output methods to take inputs from users and display

results of processing as outputs. The Console class also provides the Read() method to read the next character from the standard input stream and the ReadLine() method to read the next line

of characters from the standard input stream. The following demonstrates how to implment

basic input and output in C# console application.

using System;

namespace Samples

{

class EntryProgram

{

public static void Main(string[] args)

{

Console.Write("What is your name: ");

String name = Console.ReadLine();

Console.WriteLine("Buenos Dias, " + name + ".");

}

}

}

In the next section, the instructor will return to the discussion of GUI applications as well as the

differences between GUI and console applications. By the way, a later lecture will explain the

generic anatomy of C# programs.

C# coding

environment

and the

compiler

This section is meant to provide students with a basic understanding of three types of C# codes,

console, GUI (graphical user interface), and Windows “form”, in order to become familiar

with the editing tools, compiler, and program-testing environment.

A “console” application is a non-GUI application designed to be executed in a command-line interface. However, through this semester, students will focus on creating GUI applications.

This lecture is probably the only lecture discussing the building of console applications.

Type Description Example


Console Applications designed to run in a text-

only computer interface, such as the

Command Prompt.

GUI An application that displays its result

on a simple GUI-based dialog box.

Form A “form” is a rich client application for

desktop, laptop, and tablet PCs.

Most textbooks discuss C# programming with examples of console applications. A console

application is a computer program designed to be used via a text-only computer interface, such

as the Developer Command Prompt which is a command line interface. The following is an

example of a simple console application. The file name is “Welcome.cs”.

//File name: Welcome.cs

namespace Samples

{

class Welcome

{


{


}

}

}

The following is the sample output of the above code.

C:\cis218>sample

Welcome to CIS218 Visual C#!

GUI vs.

console

applications

Unlike text-based command-line, every GUI-based operating system (Windows, Mac, and

Linux) provides a unique GUI environment known as the “OS platform”. These OS platforms

may not be compatible to one another; therefore, each of them usually provides a platform-

specific APIs (application programming interfaces). C#, as one of the .NET languages, naturally

adopts the .NET Framework APIs.

By narrowing the scope of application development to “input” and “output”, one significant

difference between console and GUI applications is the design of the UIs (user interfaces). The

following table compares the input and output tools provided by console and GUI APIs.

Type Input Output

Console Read(), ReadLine() Write(), WriteLine()

GUI MessageBox.Show() Custom-made input box

The .NET Framework includes a MessageBox class with a Show() method to display a string text in dialog box. A MessageBox object typically contains text, buttons, and symbols to inform

and instruct the user what to do. The MessageBox class belongs to the


System.Windows.Forms namespace which provides classes for creating Windows-based

applications that take full advantage of the rich user interface features available in the Microsoft

Windows operating system. The instructor believes the use of dialog boxes is one of the

simplest approaches to create basic, simple, and standalone applications for Windows operating

systems. Interestingly, the .NET Framework does not provide a simple input dialog box. In a later lecture, the instructor will introduce a custom-made input box code prepared by the

instructor for students to use in this course.

The following is a very simple code that creates a GUI-based application. It uses the Show()

method of the MessageBox class of the.NET Framework (APIs) to display a string literal,

“Hello World”. There is a Main() method inside a programmer-defined class named Hello.

//File name: Hello.cs

namespace Samples

{

class Hello

{

static void Main()

{

System.Windows.Forms.MessageBox.Show("Hello World!");

}

}

}

By the way, this sample code also demonstrates how to use “fully qualified name” to call the

Show() method. In programming, a fully qualified path name (FQPN) is the full path of a

resource, directory or file, stored in a computer. The following technically means “Show()

function of MessageBox of Forms of Windows of the System namespace.”

System.Windows.Forms.MessageBox.Show() System

Windows

Forms

MessageBox

Show()

The following is a sample output of the above code. The text is displayed within a GUI dialog

box.

While the above example chooses to use the “fully qualified name” to call the Show() method

of the MessageBox class: System.Windows.Forms.MessageBox.Show(), programmers can

import the System.Windows.Forms namespace with the “using” directive to eliminate the

need of using “fully qualified name”, as shown below.


In the following example, the instructor adds an “using” directive to import the

System.Windows.Forms namespace; therefore, the Show() method can be called without

using the “fully qualified name”. The above code can be re-written to the following.


//File name: Hello.cs


namespace Samples

{

class Hello

{

static void Main()

{

MessageBox.Show("Hello World!");

}

}

}

It is necessary to note that the Main() method does not include any parameter as opposed to

Main(string[] args) of console applications. Again, GUI applications do not use

command-line interface (as do console applications); therefore, they do not need to collect

arguments generated by the command-line interface.

Interestingly, by running the GUI application in a Command Prompt, the args parameter can

still pick up command-line arguments if the Main() method may contains the args parameter.

Again, the args keyword represents an array of command-line arguments. In the following

example, if compiled with csc.exe sample.cs and then launched in the Command Prompt,

can pick up two strings. The combined string literals is then display in a message box. The

MessageBox class provides the definition to create a graphical user interface that displays

messages in a pop-up window.

//File Name: sample.cs


namespace Sample

{

static class Example

{


{

MessageBox.Show("Welcome, " + args[0] + " " + args[1]);

}

}

}

A sample output looks:

C:\cis218>sample.exe Taylor Swift

The GUI output looks:

Students will use the message box frequently throughout this semester. The next section will

introduce the “Windows Forms application. Yet, a later lecture will discuss how to hand-code

“Windows Forms” applications in detail.


Windows

Forms

application

Microsoft defines the term “form” as a rectangular area that has a combination of GUI

components to present information and/or interact with the users by accepting input from the

user and displaying the results of processing. Most applications run in a Windows operating

system are “form-based” application. The following figure is a sample of form-based

application.

“Windows Forms”, on the other hand, is the name given to the application programming

interfaces (APIs) included as a part of the .NET Framework. C# is an ideal language for

creating “Windows form applications”. Throughout this course, students will often write code

to inherit the System.Windows.Forms.Form class provided by the .Net Framework to create

multiple-control Windows form applications. The term “control” refers to GUI components

such as a button, a checkbox, or a drop-down menu. A later lecture will discuss how to create a

rich client application in detail.

The bare minimum code to create a generic Windows form is illustrated below. It uses the

Form class of the System.Windows.Forms namespace to declare and construct a Windows

form object named “form1”. It also uses the Run() method of the Application class to begin

running a standard application’s message loop on the current thread to create the “form1”

object.

// File Name: Sample.cs

using System;


namespace Samples

{

class Sample

{

static int Main()

{

Form form1 = new Form();

Application.Run(form1);

return 0;

}

}

}

Programmers can manually type in the above code in a generic text editor (such as Notepad), as

shown below, save it as a text file named sample.cs, and then compile it.

Windows form applications support the “Event Model” which can interact with users. A later

lecture will discuss “event programming” in detail. The following shows how a Windows

application uses its Button control to handle the “Click” event.


using System;


namespace Samples

{

class Sample

{

static int Main()

{


Button button1 = new Button();

button1.Text = "Close";

button1.Location = new System.Drawing.Point(10, 10);

button1.Click += new EventHandler(button1_Click);

form1.Controls.Add(button1);


return 0;

}

private static void button1_Click(Object sender, EventArgs e)

{

Application.Exit();

}

}

}

The above code creates a simple Windows application that looks similar to the following. By

clicking the “Close” button, the application will be destroyed.

void Main()

vs. int Main()

Many students who are new to C# often confused about the difference between void Main()

and int Main(). They also wonder if C# allows the Main() method to return either void or an

int? This issue could have a historical background that needs students’ attentions. Older

languages, such as C and C++, require the console application’s “main()” method to return an

int value to report (or communicate) processing status of the main() method to/with other

programs or scripts that invoke the executable file.

Yet, such reporting or communication is not required in C#, particularly the “Windows form

applications” written in C#. When a program executes in the Windows environment, any value

returned from the Main function is stored in an environment variable called ERRORLEVEL. In

the instructor’s opinion, using either void or int type of Main() in C# is just a compromise of programmers’ preferences.

The following compares these two types, void and int. Both programs produce the same result;

however, the int type must return an integer to its caller. By the way, traditionally, a return

value of zero indicates successful execution. The example on the right is a simple program that

returns zero from the Main function. The zero indicates that the program ran successfully.


void int using System;


public class Number

{

static void Main()

{

MessageBox.Show("Hello!");

}

}

using System;


public class Number

{

static int Main()

{

MessageBox.Show("Hello!");

return 0;

}

}

Apparently, returning void allows for slightly simpler code. Most of the sample codes provided

by Microsoft also choose to use void type. The instructor thus chooses to use the void type

throughout this course. Throughout this course, students can treat the following as the “template code” which will be seen on most of the sample programs provided in lectures.

using System;

public class Example

{

public static void Main()

{

}

}

Practical

Examples

Along the history, C and C++ are the most popular programming languages while Java gained a

good ground for sometimes before Python became a popular language. On the hand, C#

language is recently becoming one of the most versatile, powerful, innovative, and evolving

programming languages ever. Programmers can use C# to develop enterprise-level software,

while freelancers can use C# to develop simple and casual application to take advantage of

the .Net Framework. For example, the following is a simple C# code that access the .Net

Framework’s System.Environment.OSVersion object and displays its VersionString

property.

using System;


class Samples

{

static void Main()

{

OperatingSystem os = System.Environment.OSVersion;

MessageBox.Show(os.VersionString);

}

}

Without much coding efforts, developers can obtain a large amount of data from a computer by using tools provided by the .Net Framework.

Review

Questions

1. Which is a valid file name of a C# code?

A. lab1.cs

B. lab1.css

C. lab1.cpp

D. lab1.csharp


2. Which can declare a namespace named "Narumi" in C#?

A. new namespace Narumi { }

B. namespace Narumi { }

C. using namespace Narumi { }

D. Namespace Narumi = new Namespace();

3. Which creates a C# class named “apple”?

A. class Apple { }

B. new class Apple { }

C. public: static class Apple { }

D. public: new class Apple { }

4. Which is the correct way to compile a Visual C# code named “lab0.cs” in the command-line

interface?

A. csc.exe /clr lab0.cs

B. csc.exe /t:win lab0.cs

C. csc.exe /s:Main lab0.cs D. csc.exe lab0.cs

5. The following is a sample code of __ application.

class Test

{

static void Main()

{


}

}

A. Windows-based GUI

B. Windows Forms

C. Console

D. All of the above

6. Which directive can eliminate the need to use fully qualified name of the following

statement?

System.Windows.Forms.MessageBox.Show("Hello World!");

A. using Windows;

B. using System.Windows;

C. #include System.Windows.Forms; D. using System.Windows.Forms;

7. Given the following code segment, which statement is correct?

static int Main(string[] args) { }

A. args is the parameter of the Main() method.

B. args is an individual String literal. C. args is an indicator to eliminate all the command-line arguments.

D. args must be declared a String variable, not an array.

8. Given the following code, which statement must be added to actually create the Windows

form?


public class Example {


static int Main() {


return 0;

}

}

A. Application.Run(new form1);

B. Application.Run(new Form);

C. Application.Run(form1);

D. Application.Run(form);

9. Given the following code, which can display "Hello world" is a pop-up message box?


public class Example {

static int Main() {

return 0;

}

}

A. MessageBox->Show("Hello world!");

B. MessageBox::Show("Hello world!");

C. MessageBox.Show("Hello world!");

D. MessageBox Show("Hello world!");

10. The following is an example of ___.

namespace Orange {

partial class orange { }

partial class orange { }

}

A. hybrid namespace

B. hybrid class

C. partial namespace

D. partial class


Lab #1 Introducing Visual C#

Preparation #1: “Hide extensions for known file types” option.

(For Windows 10/8 Users Only) (For Windows 7/Vista Users Only)

1. Launch the Windows Explorer.

2. Click “View”.

3. Check the “File name extension” option.

4. Proceed to Preparation #2 now.

1. Launch the Windows Explorer.

2. Click “Folders and search options”.

3. Click the View tab, and then uncheck the

“Hide extensions for known file types”

option.

4. Click OK. Proceed to Preparation #2 now.

Preparation #2: Download Visual C# 2017 Community

1. Use Internet Explorer to visit https://www.visualstudio.com/downloads/ to download and install the

Visual Studio Community for free. The entire installation procedure might take up to 40 minutes or longer.

Preparation #3: Searching for the Developer Command Prompt

Windows 10 Windows 8.1

1. Open the Start menu, press the Windows logo key

on the keyboard.

2. On the Start menu, enter developer. This step will

bring a list of installed apps.

1. Go to the Start screen, press the Windows logo

key on the keyboard.

2. On the Start screen, press CTRL + TAB to open

the Apps list and then enter V. This will bring a

list of installed apps.

3. Choose the Developer Command Prompt.


3. Choose the Developer Command Prompt (for

VS2017).

Learning Activity #1: Using Visual C# Command Line Compiler

1. On the keyboard, hold the Windows logo ( ) and press E to launch the Windows Explorer.

2. Right click the “C” drive (or “Local Disk (C:)”), select “New” and then “Folder” to create a new directory

named “C:\cis218”.

3. Launch the Developer Command Prompt. Do not use regular Windows Command Prompt.

4. In the prompt, type cd c:\cis218 and press [Enter] to change to the C\cis218 directory. The prompt changes

to:

C:\Program Files\Microsoft Visual Studio\2017\Community>cd c:\cis218

C:\cis218>

5. In the prompt, type notepad lab1_1.cs to create a new source file named “lab1_1.cs”, and then click Yes.

C:\cis218>notepad lab1_1.cs

6. Type the following contents into the Notepad as shown in Figure 1-1:

using System;


class lab1_1

{

static void Main()

{

MessageBox.Show("Welcome to CIS218 Visual C#!");

}


} Figure 1-1

7. Click File and then Save to save the file. Click File and then Exit to exit Notepad.

8. Type csc /target:winexe lab1_1.cs and press [Enter] to compile the source file. This process creates a

new executable console program named lab1_1.exe.

C:\cis218>csc csc /target:winexe lab1_1.cs

Microsoft (R) Visual C# Compiler version 4.0.30319.17929

for Microsoft (R) .NET Framework 4.5

Copyright (C) Microsoft Corporation. All rights reserved.

9. Type dir lab* and press [Enter] to verify if the compilation succeeds, which means the compiler creates a

self-executable file named “lab1_1.exe”.

Volume in drive C has no label.

Volume Serial Number is 30D5-B37B

Directory of C:\CIS218

08/25/2016 06:17 PM 104 lab1_1.cs

08/25/2016 06:18 PM 3,072 lab1_1.exe

2 File(s) 3,176 bytes

0 Dir(s) 31,759,298,560 bytes free

10. Type lab1_1.exe to run the console program. The output looks:

11. Download the “assignment template” and rename it to lab1.doc if necessary. Capture a screen shot similar to the

above and paste it to the Word document named lab1.doc (or .docx).

Learning Activity #2: console argument

1. Under the C:\cis218 directory, type notepad lab1_2.cs and press [Enter] to create a new source file named

“lab1_2.cs”, and then type the following contents.


namespace Sample

{

static class Example

{


{

MessageBox.Show("Welcome, " + args[0] + " " + args[1]);

}

}

}

2. Type csc /target:winexe lab1_2.cs and press [Enter] to compile.

3. Type lab1_2.exe Taylor Swift and press [Enter] to test the program.


4. Capture a screen shot similar to the above and paste it to the Word document named lab1.doc (or .docx).

Learning Activity #3: Partial class

1. Under the C:\cis218 directory, type notepad lab1_3.cs and press [Enter] to create a new source file named

“lab1_3.cs”, and then type the following contents.

using System;



{

static String str = "Hello World!";

}


{


{

MessageBox.Show(str); // a message box

}

}


3. Type lab1_3.exe and press [Enter] to test the program.


Learning Activity #4: A Generic Windows form

1. Under the C:\cis218 directory, type notepad lab1_4.cs and press [Enter] to create a new source file, and

then add the following contents.

using System;


namespace Samples

{

class Sample

{

static int Main()

{



return 0;


}

}

}




Learning Activity #5:

1. Under the C:\cis218 directory, type notepad lab1_5.cs and press [Enter] to create a new source file, and

then add the following contents.

using System;


class Samples

{

static void Main()

{

OperatingSystem os = System.Environment.OSVersion;

MessageBox.Show(os.VersionString);

}

}




Submittal

1. Complete all the 5 learning activities. Create a .zip file named lab1.zip containing ONLY the following self-

executable files. (See Appendix C for instructions)

• lab1_1.exe

• lab1_2.exe

• lab1_3.exe

• lab1_4.exe

• lab1_5.exe

• lab1.doc (or .docx) [You may be given zero point if this Word document is missing]


2. Log in to course site, and enter the course site.

3. Upload the zipped file to Question 11 of Assignment as response.

Programming Exercise:

1. Use Notepad to create a new file named ex01.cs with the following heading lines (be sure to replace

YourFullNameHere with the correct one):

//File Name: ex01.cs

//Programmer: YourFullNameHere

2. Under the above two heading lines, write C# codes to display a text “YourFullNameHere wrote this code!” in a

message box, as shown below. [Hint: read one of the sample codes in the lecture note and learning activity #1.]

3. Download the “programming exercise template” and rename it to ex01.doc. Capture a screen shot similar to the above figure and then paste it to the Word document named “ex01.doc” (or .docx).

4. Compress the source code (ex01.cs), the executable (ex01.exe), and the Word document (ex01.doc or .docx) to

a .zip file named “ex01.zip”.

Grading Criteria:

• You must be the sole author of the codes.

• You must meet all the requirements in order to earn credits.

• You must submit both source code (ex01.cs) and the executable (ex01.exe) as response to Question 12 of

Assignment 01 to earn credit.

• No partial credit is given.

Appendix A: Compress files to .zip format

1. Open the Windows Explorer and change to the directory that has all the following files (e.g. C:\cis218).

lab1_1.exe, lab1_2.exe, lab1_3.exe, lab1_4.exe, and lab1_5.exe

2. Highlight all the five files, and then right click the highlighted area as shown below:

Must be your full name


3. Select “Send to”, and then “Compressed (zipped) folder”. This step will create a .zip file.

4. Right click the lab1_x.zip (while x is a number) file and then select “Rename”.

5. Change the file name to “lab1.zip”.

Studio’s Developer Command Prompt source codes C#...

Documents

Transcript of Studio’s Developer Command Prompt source codes C#...