Types of net applications and their basic concepts. Microsoft platform. Overview of architecture and capabilities. What programming languages support .NET technology

Types of .NET Applications

The C# language can be used to create console applications - text-based applications that run in a DOS window. Most likely, such applications will be used to test class libraries. However, more often you will use C# to create applications that have access to many of the technologies associated with .NET. This article provides a brief overview of the different types of applications that can be written in C#.

Creating ASP.NET Applications

Initially, the advent of ASP.NET 1.0 fundamentally changed the web programming model. ASP.NET 4 is the senior release of the product and is built on the foundation of previous achievements. ASP.NET 4 introduces major revolutionary steps aimed at increasing productivity. the main objective ASP.NET 4 allows you to build powerful, secure, dynamic applications using the smallest possible amount of code.

ASP.NET Features

First, and perhaps most important, is that the pages structured. That is, each page is, in fact, a class inherited from class .NET System.Web.UI.Page, which can override a set of methods called during the life cycle of a Page object. (You can think of these events as page-specific relatives of the events OnApplication_Start And OnSession_Start, which came in global.asax files in classic ASP.) Because the functionality of pages can be distilled into event handlers for specific purposes, ASP.NET pages are much easier to understand.

Another nice feature of ASP.NET pages is that they can be created in Visual Sludio 2010, the same environment in which the business logic and data access components used by these same ASP.NET pages are programmed. A Visual Studio 2010 project, or solution, contains all the files associated with an application. Moreover, classic ASP pages can be debugged directly in the editor. In the old days with Visual InterDev, there was an annoying need to specifically configure InterDev and the project's web server to enable debugging.

For greater clarity, ASP.NET's code-behind feature allows you to extend the structured approach even further. ASP.NET allows you to isolate the server-side functionality of a page in a class, compile that class along with other pages into a DLL, and place that DLL in a directory below the HTML portion. The @Page directive at the beginning of the page associates this file with a class. When the browser requests a page, the web server generates events in a class located in the page's class file.

The last but not least important feature of ASP.NET that should be mentioned is increased performance. While classic ASP pages were interpreted every time the page was accessed, ASP.NET pages were cached on the web server after they were compiled. This means that all subsequent ASP.NET page requests are faster than the first.

ASP.NET also makes it easier to write pages that display forms in the browser that you can use in corporate network. The traditional view of forms-based applications is that they provide a rich user interface, but are more difficult to maintain because they run on many client machines. For this reason, people rely on form-centric applications only when they need a rich interface and can provide reliable user support.

Web Forms

To make designing web pages even easier, Visual Studio 2010 offers the Web Forms library. This tool allows you to graphically create ASP.NET pages, just like you create windows in Visual Basic 6 and C++Builder. In other words, you will need to drag the necessary controls from the toolbar onto the form surface, then slightly adjust the form code and write event handlers for the controls. When you use C# to create a web form, you create a C# class that inherits from a base class Page, and an ASP.NET page that exposes this class as its code-behind. Of course, you don't have to use C# to create a web form; For this, you can also use Visual Basic 2010 or any other .NET-oriented language.

In the past, the complexity of web development has kept some development teams from trying to master it. To achieve success in web application development, you had to know a lot different technologies, such as VBScript, ASP, DHTML, JavaScript, etc. Applying Web Forms concepts to web pages has made building web applications much easier.

Web Server Controls

Controls used in Web forms are not controls in the same sense that ActiveX controls are. Instead, they are XML tags that belong to the ASP.NET namespace, which the web browser dynamically transforms into HTML tags and client-side scripts when that page is requested. The amazing thing is that a web server can render the same server side controls different ways, generating a transformation that matches the specific web browser that made the request. This means that you can now easily create perfect web page user interfaces without having to worry about how to get the page to work in any of the available browsers - Web Forms takes care of that.

XML Web Services

Today, HTML pages make up the majority of World Wide Web traffic. However, with XML, computers have a device-independent format that they can use to communicate on the Internet. In the future, computers will be able to use XML to exchange information instead of sending each other messages over leased lines in a special proprietary format like EDI (Electronic Data Interchange). XML Web services are designed for a service-oriented Web environment, where remote computers provide dynamic information to each other that can be parsed and reformatted before producing its final presentation to the user. XML Web services are a simple way for computers to provide information in XML form to other computers on the Internet.

In technical terminology, an XML Web service in .NET is an ASP.NET page that returns XML code instead of HTML code when requested by clients. Such pages rely on code-behind DLLs that contain classes inherited from WebService. The Visual Studio 2010 IDE provides a mechanism that makes it easy to create web services.

A business or organization may prefer XML Web services for two main reasons. The first reason is that they are based on HTTP; Web services can use existing HTTP-based networks as intermediaries to transfer information. Another reason is that because XML Web services use XML, the format of the data transferred is self-documenting, open, and platform independent.

Creating Windows Forms

Although C# and .NET are designed specifically for web development, they still support so-called "thick" client applications - i.e. applications that should be installed on the machine end user, where most of the processing is done. This is provided by the Windows forms library.

However, if you are starting to learn the .NET platform, I would didn't recommend you learn Windows Forms, and immediately move on to learning the latest WPF technology.

Windows Presentation Foundation (WPF)

One of latest technologies revolutionary in nature is Windows Presentation Foundation (WPF). WPF relies on the use of XAML to build applications. The abbreviation XAML stands for Extensible Application Markup Language - an extensible application markup language. This new way of building applications inside the Microsoft framework, first introduced in 2006, is part of the .NET Framework 3.0, 3.5, and 4. This means that in order to run any WPF application, you must ensure that the client machine has the framework installed .NET Framework 3.0, 3.5 or 4. WPF applications are available for Windows 7, Windows Vista, Windows XP, Windows Server 2003 and Windows Server 2008 (only these operating systems allow you to install the .NET Framework 3.0, 3.5 or 4).

XAML is an XML declaration used to create forms that represent all the visual aspects and behavior of WPF applications. Because you can work with a WPF application programmatically, this technology represents a step in the direction of declarative programming that the industry is moving toward today. Declarative programming means that instead of creating objects by writing code in a compiled language such as C#, VB or Java, everything is declared using XML-like programming.

Windows Services

Windows Service (originally called NT Service) is a program designed to run in the background in Windows environment NT/2000/XP/2003/ Vista/7 (but not Windows 9x). These services are useful when you need to organize the continuous operation of programs that are ready to respond to events, without the need for them to be explicitly launched by the user. A good example is a World Wide Web Service on web servers that listens for web requests from clients.

Developing services in C# is very easy. In namespace System.Service.Process Basic classes of the .NET environment are available that allow you to solve most of the template problems associated with system services. Additionally, Visual Studio .NET allows you to create a C# Windows Service project that uses C# source code to build a Windows service.

Windows Communication Foundation (WCF)

As you explore the ways Microsoft technologies move data and services from one point to another, you'll find that you have a wide variety of options at your disposal. possible solutions. For example, you can use ASP.NET Web Services, .NET Remoting, Enterprise Services, or MSMQ. Which technology to choose? The answer to this question is dictated by what you are trying to achieve, as each of these technologies is preferable in a specific situation.

With this in mind, Microsoft has really brought all of these technologies together, and in the .NET Framework 3.0, and its inclusion in the .NET Framework 3.5 and 4, there is a single way to move data - Windows Communication Foundation (WCF). The WCF library provides the ability to initially build a service and then deliver that service in different ways (even over different protocols) simply by changing the configuration file. WCF is a very powerful new means of connecting distributed systems.

Windows Workflow Foundation (WF)

The Windows Workflow Foundation (WF) service was first introduced in the .NET Framework 3.0, but has now undergone a major overhaul that many will now find much more useful. You'll find that Visual Studio 2010 has greatly improved the way you work with WF, making it much easier to create your own workflows. You'll also find new flow controls, the Flowchart class, as well as a number of new actions such as DoWhile, ForEach, and ParallelForEach.

Annotation: Microsoft .NET Initiative. Compatibility, reliability and component reuse issues. .NET Framework. Common Language Runtime Environment (CLR). Pseudo-machine language CIL (controlled by assembler). JIT compiler. Programming languages. Assemblies. Metadata. Garbage collector. .NET Framework Class Library

Problems of developing modern information systems

Integration problems

Modules written in different languages, using different APIs (or API versions) or different data representation formats;
Programs developed for various platforms within a single software package;
Systems using different software models.

Integration problems with legacy code are especially common. When solving integration problems, incompatibility problems arise.

Portability issues

Increasingly, programs are required to support multiple platforms (for example, the ability to work with the program on Windows platform and Mac OS).

Version problems

Windows developers are aware of a version compatibility problem known as DLL hell. This "hell" occurs when components installed for a new application replace components of the old application. As a result, the old application starts to work incorrectly or stops working.

Resource management

One of the problems of programming is the management and correct release of resources, files, memory, screen space, network connections, database resources, etc. Incorrect management of these resources can lead to incorrect program execution.

Type safety

When they mention a type safety problem, they mean incorrect handling of data types: attempts to access memory areas outside the boundary of the type, attempts to call methods that are not present on the type, or attempts to call a method that takes type A as a parameter and pass it as a parameter. object type B.

Failure Handling

When developing Windows applications using the Win32 API, some functions return exceptions, others return status codes, and others return HRESULTs. Thus, there is no consistent mechanism for handling failures and it is possible to ignore some exceptions, which makes the code unsafe.

These and other development problems information systems The Microsoft .NET platform helps solve this problem.

Solving problems of developing information systems in .NET

One way to solve the problem of heterogeneity is to develop and support standard software interfaces that facilitate the task of transferring applications to servers of various platforms. However, applications may use databases, communications, and other services whose interfaces are not components of the programming language or environment. Another method used by manufacturers to solve the problem of heterogeneity is to support standard protocols. Systems supporting the same protocol can communicate with each other, even if they rely on different machine architectures and operating systems.

Technology. NET is a way to develop and deploy software, which, using widely used standards such as HTTP and XML, implements program interaction and provides access to numerous software services over the Internet. Technology includes. NET Framework is a platform for developing and executing applications that simplifies and speeds up development, supports full object-oriented programming for the Web, eliminates many types of the most common software errors, provides a common API for all languages.

What makes up Microsoft .NET

NET Framework - application development infrastructure. Its main components are the Common Language Runtime and a class library. NET Framework Class Library.

Common Language Runtime

Common Language Runtime (CLR) is a common language runtime that abstracts operating system services and executes managed applications, any action of which must be authorized by the CLR.

All code for the .NET platform is converted by the CLR to CIL intermediate code. Therefore, developers can easily integrate code written for .NET in various programming languages. Anything that can be done in one .NET-compatible language (with rare exceptions) can be done in any other. Code in these languages is compiled into code in one language - CIL.

The CLR sits on top of the operating system and provides virtual environment for managed applications. Code for the .NET platform is either executed by the CLR or is allowed to be executed outside of it.

The code for the CLR is in the form of Common Intermediate Language (CIL) pseudo-machine language commands. These instructions are compiled into machine code for the appropriate processor type on a just-in-time basis at runtime. Typically, a method is compiled once, the first time it is called. The result is then cached in memory to avoid delays in repeated calls. The JIT compiler optimizes code specifically for the processor on which the code is executed.

By converting CIL instructions into processor instructions, the JIT compiler verifies the code for type safety.

It is virtually impossible to execute a command that accesses an area of memory that the command does not have permission to access. A managed application eliminates the problem of misinitialized pointers by preventing a type from being converted to something it is not, which is a type safety violation. The CLR does not allow methods to be called with a destroyed stack frame.

Resources allocated by managed code are freed by the garbage collector. In other words, the programmer only allocates memory, but does not free it - the CLR does this. The garbage collector keeps track of all references to objects created by a program and destroys those objects when the memory they occupy is needed elsewhere. This resolves the problem of memory leaks in managed code applications.

Code verification is also the basis of the CLR's ability to run multiple applications within a single process. The process is divided into virtual compartments - application domains. This improves the efficiency of memory allocated to processes. Application domains are no less secure than processes because their boundaries cannot be violated by managed applications.

.NET Framework Class library (FCL)

.NET includes class library assemblies. NET Framework Class library (FCL), containing definitions of several thousand types, each of which provides some functionality. Sets of "related" types are collected into separate namespaces. Thus, the System namespace contains a base class, Object, from which all other types are ultimately derived.

Thus, every entity in. NET is an object with its own fields and methods.

In addition, System contains types for integers, characters, strings, exception handling, console input/output, a group of types for safe conversion from one type to another, data formatting, random number generation and performing mathematical operations. All applications use types from the System namespace.

To modify an existing FCL type, you can create your own derived type. You can create your own namespaces. All this will strictly comply with the principles proposed by the platform. NET

Here are some of the most common namespaces and short description types contained there.

Basic FCL namespaces

Namespace	Content
System	Fundamental data types and helper classes
System.Collections	Hash tables, variable arrays, and other containers
System.Data	ADO .NET Classes for Data Access
System.Drawing	Classes for graphics output (GDI+)
System.IO	File and Stream I/O Classes
System.Net	Classes for working with network protocols, for example with HTTP
System.Reflection	Classes for reading and writing metadata
System.Runtime.Remoting	Classes for distributed applications
System.ServiceProcess	Classes for creating Windows services
System.Threading	Classes for creating and managing threads
System.Web	HTTP Support Classes
System.Web.Services	Classes for developing web services
System.Web.Services.	Classes for developing web service clients Protocols
System.Web.UI	Main classes used by ASP .NET
System.Web.UI. WebControls	ASP .NET Server Controls
System.Wndows.Forms	Classes for applications with graphical interface user
System.Xml	Classes for reading and entering data in XML format

All managed applications use

Common Language Runtime) and a class library...

The .NET Framework and the CTS Specification

The C# language and its support are currently associated with the .NET Framework developed by Microsoft. The named platform (see) includes: common language runtime (CLR - Common Language Runtime Framework Class Library). It should be noted...
(PROGRAMMING. BASIC COURSE C#)

Installing the .NET Framework and Visual Studio

In Windows 7 and 8, the .NET platform is already available and there is no need to install anything. To develop applications in the .NET platform, you need to install the Visual development system C# 2012 (or 2013) Express Edition – free version Visual Studio development environment (reduced, but with almost...
(Object-oriented programming)

C# TYPES AND .NET FRAMEWORK TYPES

The C# language and its support are currently associated with the .NET Framework developed by Microsoft. The named platform (see) includes: common language runtime (CLR - Common Language Runtime) and a class library...
(PROGRAMMING. BASIC COURSE C#)

The .NET Framework and the CTS Specification

The C# language and its support are currently associated with the .NET Framework developed by Microsoft. The named platform (see) includes: common language runtime (CLR - Common Language Runtime) and class library (FCL - Framework Class Library). It should be noted...
(PROGRAMMING. BASIC COURSE C#)

Good day. Alexey Gulynin is in touch. In the last article, we learned about ways to pass arguments to a method in C#. In this article I would like to tell you again (more in simple words), which is .Net Framework and Visual Studio. This article is a continuation of the Visual Studio description and .Net Framework articles .Net Framework is a CLR (Common Language Runtime) environment. core component of the .Net Framework), which ensures the execution of managed code. The CLR manages this code. What is managed code? Code written for the .NET Framework is not compiled into final machine code, but into an intermediate language (the so-called IL - Intermediate Language). Then this assembly is transmitted to the user (the machine must have the .Net Framework installed), loaded into memory and translated IL commands into actions that need to be performed.

What's the point of intermediate language IL?

Firstly, it is platform independent, not tied to a specific processor.

Secondly, its presence allows the CLR to control the operation of your program, i.e. do not allow her to do any unacceptable things (for example, memory manipulation).

Second important component after CLR is Class Library. The .NET Framework includes a large number of classes, divided into namespaces, that provide all the basic functionality. This is the functionality that your program may require, for example, working with files, the network, processes, and the graphics subsystem.

Third component are Development Frameworks (in other words, development libraries). This includes libraries such as WPF (Windows Presentation Foundation), ASP.NET, Entity Framework, WCF (Windows Communication Foundation), Windows Store etc. In fact, these are also classes. The difference is that these classes are designed to solve specific problems:

WPF - for working with graphical applications
ASP.NET - for working with web applications
WCF - for working with the network and creating distributed (client-server) applications
Entity Framework - for working with the database.

At the time of writing this article, the latest version is .Net Framework 4.6

The main development environment recommended by Microsoft is Visual Studio. Microsoft usually has this situation: how does it turn out? a new version.NET Framework, then after a while a new version of Visual Studio comes out. What's included in Visual Studio (basic):

Text editor with syntax code highlighting
IntelliSence help system (can be called automatically or by the keyboard shortcut Ctrl + Space (spacebar)
Compilers from different languages
Rapid Application Development (RAD)
Visual designer of interfaces, diagrams
Component for working with servers and databases
IIS web server and SQL server Express option
Debuggers, profilers, components that allow you to handle errors
MSDN Help System

As of this writing, the latest version is Visual Studio 2015.

How the concept of programs works in Visual Studio. In the studio there is the concept of “Project” and “Solution”. A project is a unit of compilation. It consists of a set of files. The entire project is usually compiled into an assembly (exe file or dll file). Projects can be grouped into Solution. A Solution is simply a collection of projects that may or may not be related to each other (usually they are).

The set of means by which programs are written, corrected, converted into machine codes, debugged and launched is called development environment or shell. Platform.Net or .Net Framework- it's more than just development environment programs, this is a new revolutionary combination of previously separate technologies by Microsoft, which allows you to develop different types of applications in different programming languages for different operating systems.

NET Framework is an add-on to operating system, which can be any Windows version, Unix and any OS in general (according to the developers), and consists of a number of components. So, . NET Framework includes:

Four official languages: C#, VB.NET, Managed C++ and JScript .NET.
A common language object-oriented runtime (CLR) shared by these languages to create applications.
A series of interconnected class libraries under the common name FCL (Framework Class Library).

The main component of the platform. NET Framework is a common language runtime environment for CLR programs. The name of the environment - "common language runtime" - speaks for itself: it is a runtime environment that is suitable for various programming languages. CLR functions include:

two-step compilation: converting a program written in one of the programming languages into managed code in intermediate language ( Microsoft Intermediate Language, MSIL, or simply IL), and then converting the IL code into processor-specific machine code, which is executed using virtual machine or a JIT compiler (Just In Time compiler - compiling exactly at the right time);
code management: loading and executing ready-made IL code using a JIT compiler;
accessing metadata for verification purposes code security;
memory management when placing objects using the garbage collector (Garbage Collector);
handling exceptions and exceptional situations, including cross-language exceptions;
implementing interaction between managed code (code written for CLR) and unmanaged code;
support for services for developing various types of applications.

The next component. Net Framework is an FCL - Platform Class Library. This library is divided into several modules in such a way that it is possible to use one or another part of it depending on the required results. So, for example, one of the modules contains the “bricks” from which you can build Windows applications, the other contains the “bricks” necessary for organizing work on the network, etc.

Part of the FCL is devoted to describing basic types. A type is a way to represent data; identifying the most fundamental of them makes it easier sharing programming languages using. NET Framework. Collectively this is called the Common Type System (CTS - unified type system).

In addition, the FCL library includes the Common Language Specification (CLS - common language specification), which establishes: the basic rules of language integration. The CLS specification defines minimum requirements requirements for the platform language. NET. Compilers that meet this specification produce objects that can interact with each other. Therefore, any CLS-compliant language can use all the features of the FCL library.

As already noted, the main languages intended for the platform. NET Framework are C#, VB. NET, Managed C++ and JScript. NET. For these languages, Microsoft offers its own compilers that translate the program into IL code, which is executed by the CLR JIT compiler. Besides Microsoft, several other companies and academic organizations have created their own compilers that generate code that runs in the CLR. Currently, compilers are known for Pascal, Cobol, Lisp, Perl, Prolog, etc. This means that you can write a program in, for example, Pascal language, and then, using the appropriate compiler, create managed code that will run in the CLR.

Concepts of application, project, solution

NET Framework does not impose any restrictions on the types of applications that can be created. That said, let's take a look at some of the most common application types:

Console applications allow you to output to the "console", that is, to a shell window.
Windows applications that use Windows interface elements, including forms, buttons, checkboxes, etc.
Web applications are web pages that can be viewed by any web browser.
Web services are distributed applications that allow you to exchange virtually any data over the Internet using a single syntax, regardless of what programming language was used to create the web service or on what system it is hosted.

An application under development is called a project. Several applications can be combined into a solution.

A convenient application development environment is Visual Studio .Net.

Visual Studio .Net development environment

In this course we will learn the C# language. Let's start getting acquainted with the language by developing console applications. We will use Visual Studio as our development environment. Net (VS).

You can create C# source code files using the usual text editor, for example, Notepad, and compile them into managed modules using the compiler command line, which is a component. NET Framework. However, it is most convenient to use VS for these purposes because:

VS automatically performs all the steps required to compile the source code.
The VS text editor is configured to work with languages supported by VS, such as C#, so it can intelligently detect errors and prompt you as you type to find exactly what code is needed.
VS includes programs that let you create Windows and Web applications using simple drag-and-drop user interface elements.
Many types of projects that can be created in C# can be developed based on "skeleton" code that is included in the program in advance. Instead of starting from scratch each time, VS allows you to use existing source code files, which reduces the time required to create a project.

Creating the first project

To create a project, launch VS, and then select the command from the VS main menu File – New - Project. Then a dialog menu will open New Project(see Fig. 1.1).

Rice. 1.1.

In field Project types should choose Visual C#, in field Templates – Console Application.

In line Name enter the application name Hello. Note that the same name will appear in the line Solution Name. Uncheck the box Create directory for Application(for now we are creating a simple application and there is no need to complicate its structure).

In line Location determine the location on the disk where you want to save your project. And press the button OK. An approximate view of the screen is shown in Fig. 1.2

Rice. 1.2.

In the upper right part there is a project management window Solution Explorer View - Solution Explorer. This window lists all the resources included in the project:

AssemblyInfo.cs – information about assembly.
As a result of its execution, the compiler creates a so-called assembly– a file with an exe or dll extension that contains IL code and metadata.
System, System.Data, System.Xml – links to standard libraries.
Program.cs - program text in C# language.

Comment. In other versions of VS, this also includes a file with the ico extension, which is responsible for the appearance of the application shortcut.

At the bottom right of the screen there is a properties window. Properties. If it is closed, then you can enable it with the command View - Properties. This window displays the most important characteristics of the selected element.

The main screen space is occupied by the editor window, which contains the program text created automatically by the environment. The text is a frame into which the programmer will add required code. In this case, reserved words are displayed in blue, comments in green, and main text in black.

The text is structured. Clicking on the minus sign will hide the code block; clicking on the plus sign will open it.

Let's open the folder containing the project and look at its structure (see Fig. 1.3). Files in bold will only appear after compilation.

Rice. 1.3.

At this stage, the following files will be of particular interest to us:

Hello.sln– the main file responsible for the entire project. If you need to open a project for editing, you need to select this file. The remaining files will open automatically.
Program.cs– a file that contains source code - code written in C#. It is this file that we will work directly with.
Hello.exe– a file that contains the generated IL code and project metadata. In other words, this file is a ready-made application that can be executed on any computer on which the .Net platform is installed.

Now let's look at the program text itself.

using System is a directive that allows the use of standard class names from the namespace System directly without specifying the name of the space in which they were defined.

Keyword namespace creates its own namespace for the project, which by default is called the project name. In our case, the namespace is called Hello. However, the programmer has the right to specify a different name. A namespace limits the scope of a name, making it meaningful only within that space. This is done so that you can give names to program objects without worrying that they will match names in other applications. Thus, namespaces allow you to avoid conflicting names of software objects, which is especially important when applications interact.

C# is an object-oriented language, so a program written in it will be a collection of classes interacting with each other. A class named Program was automatically created (other versions of the framework may create a class named Class1 ).

This class contains only one method - the Main() method. The Main() method is the entry point to the program, i.e. exactly with this method The application will start running. Every C# program must have a Main() method.

Comment It is technically possible to have multiple Main() methods in one program, in which case you would need to use a command line parameter to tell the C# compiler which Main() method is the entry point to the program.

Debug-Start Debugging If the program is executed without errors, a message will be displayed in the console window, which will flash and quickly close. To view the message in normal mode, press Ctrl+F5 or run the command Debug-Start Without Debugging.In our case, the following console window will open:

If the program code contains errors, for example, a semicolon is missing after the output command, then after pressing the F5 key, a dialog box will open in which a message will be displayed stating that an error has been detected and a question whether to continue working further. If you answer Yes, then the previous successfully compiled version of the program will be executed. Otherwise, the process will be stopped and control will be transferred to the error list window Error List.

Exercise. Change the text of the code so that the message is displayed on the screen: Hurray!!!Today computer science!!!