本文为转载，学习研究
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#.