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#.