Professional C# 6 and .NET Core 1.0 - Creating Hello, World! with Visual Studio

本文为转载，学习研究

Creating Hello, World! with Visual Studio

Chapter 1, “.NET Application Architectures,” explains how to write a “Hello,

World!” C# program using the csc Compiler for .NET 4.6 and using dotnet tools

for .NET Core 1.0. You can also create it with Visual Studio 2015, which is done in

this chapter. 

NOTE In the first chapters of this book, Visual Studio is used as a code editor

and compiler without employing all the other features of Visual Studio.

Chapter 17, “Visual Studio 2015,” covers more about all the other options and

features offered by Visual Studio. 

Creating a Solution

First, create a solution file within Visual Studio. A solution enables you to group

multiple projects and to open all the projects of a solution together.

You can create an empty solution by selecting File???New Project and then

selecting Installed???Templates???Other Project Types???Visual Studio Solutions.

Select the Blank Solution template (see Figure 2.1). With the New Project dialog,

you can define the name of the solution as well as the directory where the solution

should be stored. You can also define whether the solution should be added to a

Git repository for source control management.

Figure 2.1 

After creating the solution, you see the content of the solution within the Solution

Explorer (see Figure 2.2). Currently, there’s only a solution file without any

content.

Figure 2.2 

Creating a New Project

Now add a new project to create the Hello, World! app. Right-click the solution in

Solution Explorer, or use the Menu button on the keyboard to open the context

menu (refer to Figure 2.2), and open the application context menu and select Add?

??New Project to open the Add New Project dialog. Alternatively, you can select

File???Add???New Project. In the Add New Project dialog, select the Console

Application (Package) template to create a console application targeting .NET

Core. You can find this project type in the tree within Installed???Templates???

Visual C#???Web (see Figure 2.3). Set the name of the application to

HelloWorldApp. 

Figure 2.3 

NOTE To open the context menu of an application, you have different

options: right-click while selecting the item where the context menu should

be opened (or left-click if you are left-handed), or select the item and press

the menu key on the keyboard (usually located between the Alt and Ctrl keys

on the right side). If your keyboard doesn’t have a menu key, press Shift +

F10. Lastly, if you have a touch pad, you can make a two-finger touch.

The Solution Explorer is no longer empty. It now shows the project and all the

files belonging to the project (see Figure 2.4).

Figure 2.4 

In Chapter 1, the project file was created by the dotnet tool, now it is created from

a Visual Studio template. Two Frameworks—.NET 4.6 and .NET Core 1.0 are

specified. With both frameworks, the NetStandard.Library 1.0 is referenced (code

file HelloWorldApp/project.json):

{

  "version":"1.0.0-*",

  "description":"",

  "authors": ["" ],

  "tags": ["" ],

  "projectUrl":"",

  "licenseUrl":"", 

  "dependencies": {

    "NETStandard.Library":"1.0.0-*"

  },

"frameworks": {

    "net46": { },

    "netstandardapp1.5": {

      "dependencies": { },

      "imports":"dnxcore50"

     }

   },

  "runtimes": {

    "win7-x64": { },

    "win10-x64": { }

   }

}

The generated C# source file Program.cs contains a Main method within the

Program class that itself is defined within the namespace HelloWorldApp (code file

HelloWorldApp/Program.cs):

using System;

using System.Collections.Generic;

using System.Linq;

using System.Threading.Tasks;

namespace HelloWorldApp

{

  class Program

  {

    static void Main(string[] args)

    {

    }

  }

}

Change this to the Hello, World! app. You need to open the namespace for using

the WriteLine method of the Console class, and you need to invoke the WriteLine

method. You also change the namespace for the Program class. The Program class is

now defined within the namespace Wrox.HelloWorldApp (code file

HelloWorldApp/Program.cs):

using static System.Console; 

namespace Wrox.HelloWorldApp

{

  class Program

  {

    static void Main()

    {

      WriteLine("Hello, World!");

    }

  }

}

Select the project in Solution Explorer and use the context menu to open

Properties (or View???Property Pages) to open the project configuration (see

Figure 2.5). On the Application tab, you can select the name of the application, the

default namespace (this is only used for new items added), and the version of the

.NET Core version that should be used for the solution. In case you select a version

that is different from your default selection, a global.json file is created that

contains this configuration setting.

Figure 2.5 

Compiling and Running the Program

The Build menu offers different options for building the program. You can either

use Build???Build Solution to build all projects of the solution, or you can build a

single project with Build???Build HelloWorldApp. Also have a look at the other

options available with the Build menu.

To generate persistent files, you can check the Produce Outputs on Build option

on the Build tab in the project properties (see Figure 2.6).

Figure 2.6 

After building the program with the Produce Outputs on Build option selected,

you can see in File Explorer the directory artifacts that contains subdirectories

for all the supported .NET Framework versions listed with the binaries.

You can run the application from within Visual Studio by using Debug???Start

Without Debugging. This starts the app as shown in Figure 2.7.

Figure 2.7 

NOTE Be sure to not start the app with Debug???Start Debugging; if you do

you will not see the output of the app because the console window

immediately closes after the app completes. You can use this method to run

the app either with setting breakpoints and debugging into the app, or by

adding aReadLine method before the end of the Main method.

You can use the Debug tab in the project properties to configure the runtime

version that should be used while running the app (see Figure 2.8).

Figure 2.8 

TIP When you have multiple projects in the same solution, you can define

what project should run by selecting the project in Solution Explorer and

opening the context menu. In the context menu click Set as Startup Project

(or Project ? Set as Startup Project). Alternatively, you can select the

solution in the Solution Explorer, and select Set Startup Projects to open the

property page for the solution where you can select what should be the

startup project. You can also define multiple projects to start.

Taking a Closer Look at the Code

Now let’s concentrate on the C# source code. First, I have a few general comments

about C# syntax. In C#, as in other C-style languages, statements end in a

semicolon (;) and can continue over multiple lines without needing a continuation

character. Statements can be joined into blocks using curly braces ({}). Single-line

comments begin with two forward slash characters (//), and multiline comments

begin with a slash and an asterisk (/*) and end with the same combination

reversed (*/). In these aspects, C# is identical to C++ and Java but different from

Visual Basic. It is the semicolons and curly braces that give C# code such a

different visual appearance from Visual Basic code. If your background is 

predominantly Visual Basic, take extra care to remember the semicolon at the end

of every statement. Omitting this is usually the biggest single cause of compilation

errors among developers who are new to C-style languages. Another thing to

remember is that C# is case sensitive. That means the variables named myVar and

MyVar are two different variables.

The first few lines in the previous code example are related to namespaces

(mentioned later in this chapter), which is a way to group associated classes. The

namespace keyword declares the namespace with which your class should be

associated. All code within the braces that follow it is regarded as being within

that namespace. The using declaration specifies a namespace that the compiler

should look at to find any classes that are referenced in your code but aren’t

defined in the current namespace. This serves the same purpose as the import

statement in Java and the using namespace statement in C++.

using static System.Console; 

namespace Wrox

{

The reason for the presence of the using static declaration in the Program.cs file

is that you are going to use a library class: System.Console. The using static

System.Console declaration enables you to refer to the static members of this class

and omit the namespace and class names. Just declaring using System; instead,

you need to add the class name for calling the WriteLine method:

using System; 

// etc.

Console.WriteLine("Hello World!");

Omitting the complete using declaration, you need to add the namespace name

invoking the WriteLine method:

System.Console.WriteLine("Hello World!");

The standard System namespace is where the most commonly used .NET types

reside. It is important to realize that everything you do in C# depends on .NET

base classes. In this case, you are using the Console class within the System

namespace to write to the console window. C# has no built-in keywords of its own

for input or output; it is completely reliant on the .NET classes.

NOTE Because almost every sample in this and the next chapters makes use

of static members of theConsole class, we will assume that a using static

System.Console; statement is present in the file for all code snippets.

Within the source code, a class called Program is declared. However, because it has

been placed in a namespace called Wrox.HelloWorldApp, the fully qualified name of 

this class is Wrox.HelloWorldApp.Program: 

namespace Wrox.HelloWorldApp

{

  class Program

  {

All C# code must be contained within a class. The class declaration consists of the

class keyword, followed by the class name and a pair of curly braces. All code

associated with the class should be placed between these braces.

The class Program contains a method called Main. Every C# executable (such as

console applications, Windows applications, Windows services, and web

applications) must have an entry point—the Main method (note the capital M).

static void Main()

{

The method is called when the program is started. This method must return either

nothing (void) or an integer (int). Note the format of method definitions in C#:

[modifiers] return_type MethodName([parameters])

{

  // Method body. NB. This code block is pseudo-code.

}

Here, the first square brackets represent certain optional keywords. Modifiers are

used to specify certain features of the method you are defining, such as from

where the method can be called. In this case the Main method doesn’t have a

public access modifier applied. You can do this in case you need a unit test for the

Main method. The runtime doesn’t need the public access modifier applied, and it

still can invoke the method. The static modifier is required as the runtime invokes

the method without creating an instance of the class. The return type is set to void,

and in the example parameters are not included.

Finally, we come to the code statement themselves:

WriteLine("Hello World!");

In this case, you simply call the WriteLine method of the System.Console class to

write a line of text to the console window. WriteLine is a static method, so you

don’t need to instantiate a Console object before calling it.

Now that you have had a taste of basic C# syntax, you are ready for more detail.

Because it is virtually impossible to write any nontrivial program without

variables, we start by looking at variables in C#.