2019-08-17 作者:www.8455.com   |   浏览(71)

For collecting and analyzing data.



  1. Inline-level element vs. Block-level element
    Inline-level elements: It occupies only the space bounded by the tags that define the inline element. (eg. <span>,<a>,<img>,<td>)
    Block-level elements: It occupies the entire space of its parent element(container), thereby creating a "block". (eg. <div>, <p>,<form>,<h1>,<ul>)

  2. HTML5 quirks mode
    Little history: In the old days of the web, pages were written in two versions: one for IE, the other for Netscape Navigator. When the web standards were made at W3C, browsers could not directly start using them, as doing so would break most existing sites on the web. Browsers therefore introduced two modes to treat new standards compliant sites differently from old legacy sites, which are the quirks mode and almost standard mode.

    Quirks Mode: the layout emulates nonstandard behavior in Navigator4 and IE5 to support the websites that were built before the widespread adoption of web standards.

    <!DOCTYPE> must be the very first thing in HTML document, before <html> tag. It is not a html tag, it is an instruction to inform the browser which version of HTML the page is written in.

  4. Cache Buster
    Purpose: Cache-buster is a unique piece of code that prevents a browser from reusing an ad it has already seen and cached, or saved, to a temporary memory file.

    How it is accomplished: It uses random number inserted into the ad tag on each page load. The random number makes every ad call look unique to the browser and therefore prevents it from associating the tag with a cached file, forcing a new call to the ad server.

    Reasons behind the technique: Cache can directly speed up the website, since it will not need to interact with server and download the content. However, for the ad on the webpage, the publisher get paid for every impression, they would prefer the browser does not use the cached ad on the hard drive. Also, the cache can mess with ads' reports and ROI calculation.

  5. px, pt AND em
    px(Pixels): the absolute size that you would see on your screen.
    pt(Points): 1pt is equal to 1/72 inch. Fixed size unit.
    em(Ems): refers to the base text size more like percentage. 1em means the same thing as a value of 100 percent.
    vh,vw(view): they are associate with the whole viewport of the browser and act as the percentage of the current viewport width and height.



1.WHY R?


  1. div
    A block level element that can be used as a container for grouping other HTML elements.

  2. span
    An inline element that can be used as a container for text.

  3. HTML Form
    It is used to select different kinds of user input, pass data to a server.

  4. iFrame
    It is used to display a webpage within a webpage. Can be a target for a link.

  5. canvas
    It is used to draw graphics, on the fly, via scripting. It is only a container for graphics. Pixel-based.

  6. SVG(Scalable Vector Graphics)
    It is used to define graphics for the web. It is a language for describing 2D graphics in XML. Every element is available within the SVG DOM, can easily interact with. Best suited for applications with large rendering areas.
    Advantages: (1). SVG images can be searched, indexed, scripted and compressed
    (2). SVG images are scalable
    (3). SVG images can be printed with high quality at any resolution
    Disadvantages: Slow redering if complex(Use DOM a lot will be slow), not suited for game application

  7. HTML local storage
    local storage: store user data(large data storage), no expiration date
    session storage: store user data, gets cleared when session ends--browser closed.
    cookie: store password, username, searched words(small text files on computer)

  8. Web worker
    It is a JavaScript that runs in the background, independently of other scripts, without affecting the performance of the page. You can continue to interact with the web page while it runs in the background.

  9. Display something with right spacing and line-breaks
    <pre>: represents preformatted text. It will show the text as it was typed in with spacing and new lines.

  10. label
    It provides a usability improvement for mouse users, because if the user clicks on the text within the label element, it toggles the control.

  11. To group a list of radio-buttons:
    All the radio-buttons should share the same name in order to extract the value from the script.

  12. Elements and New attrbiutes for <input> in HTML5:
    New semantic element: <header> <footer> <article> <section>
    New form controls like number, date, time, calendar
    New graphic elements: <svg> <canvas>
    New multimedia elements: <audio> <video>

  13. Object element
    It defines an embedded object within an HTML document. It is used to embed plug-ins(audio, video, PDF readers, Flash Players) in web pages.

  14. Application Cache
    It caches web application and accessible without an internet connection.
    Advantages: Offline Browsing, Speed, Reduced Server Load
    Disadvantages: (1). Update one file will cause the whole application to be downloaded again.
    (2). Browser will use this version until the manifest has been changed
    (3). Unreliable JavaScript API
    (4). IE 10 forbids the application cache

  15. Enable application cache
    Include the manifest attribute in the document's html tag:
    <!DOCTYPE html>
    <html manifest="demo.appcache">
    demo.appcache is a text file which contains all the files the browser should cache for the application.

  16. Cache and Cookie differences:
    (1). Different Purposes:
    Cookie is made to store information to track different characteristics related to user like the user preferences, user name, passwords etc.
    Cache is made to load the web pages faster(instead of loading from the server), typically keep the resource file like audio, video or flash files
    (2). Different Life Cycle:
    Cookie expires after some time
    Cache exists on the hard drive until manually removed

  17. Geolocation API
    HTML Geolocation API is used to get the geographical position of a user.(Not available until the user approves it)

  18. HTML Plug-in
    It extends the functionality of the HTML browser(usually use the object tag or the embed tag)

  19. HTML5 custom attribute
    Custom attributes are used to store custom data private to the page or application, for which there are no appropriate attributes or elements to describe in native HTML5.
    Custom data attributes can easily associate some scripting data with the elements without having to insert inline javascript all over the place.

    A custom attribute has two parts: name=value, eg. <div id="a" data-fruit="12"></div>. The name of the attribute must not contain any uppercase letter. It should start with a prefix:"data-". The value can be any string.
    With JS, you can extract the attribute:
    var plant = document.getElementId("a");
    var fruitCount = plant.getAttribute("data-fruit");

  20. HTML5 custom elements:
    Allow users to define new types of HTML elements. Elements are created using document.registerElement():
    var x_element = document.registerElement("x-element");
    document.body.appendChild(new x_element);
    The element name must contain a dash. This allows the parser to distinguish custom elements form regular elements but also ensures forward compatibilty when new tags are added to HTML.
    document.registerElement() has an optional argument to describe the prototype of the element.

  21. Convert the HTMl to XHTML
    XHTML is HTML4 written as an XML application.(Extensible Hypertext Markup Language)
    (1). Add XHTML doctype to the first line of every page
    <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" ";
    (2). Add an xmlns attribute to the html element of every page
    (3). Change all element names to lowercase
    (4). Close all empty elements
    (5). Change all attribute names to lowercase
    (6). Quote all attribute values

    XML and HTML difference:
    Different on purposes: XML describes data with focus on what data is.
    HTML was designed to display data with focus on how data looks.

  22. HTML5 microdata
    The Microdata spec provides a standardized syntax for additional semantic markup to your web pages to enhance the machine readability of your web pages.

    Microdata defines five HTML attributes that can be applied to any HTML5 tag. Most developers will only ever use itemscope, itemtype and itemprop. Itemref and itemid aren’t necessary to get up and running with microdata and aren’t needed by the most common formats.
    Itemscope - Indicates the element is a microdata element and its child elements are part of its microdata format.
    Itemtype - Defines the vocabulary to be used by the microdata format.
    Itemid - The unique identifier of the item, if defined by the microdata vocabulary.
    Itemprop - An individual data element.
    Itemref - Allows a microdata element to reference another element on the page to define it by either HTML id or by itemid.


Developer Guide

Welcome to the developer documentation for protocol buffers – a language-neutral, platform-neutral, extensible way of serializing structured data for use in communications protocols, data storage, and more.

This documentation is aimed at Java, C , or Python developers who want to use protocol buffers in their applications. This overview introduces protocol buffers and tells you what you need to do to get started – you can then go on to follow the tutorials or delve deeper into protocol buffer encoding. API reference documentation is also provided for all three languages, as well aslanguage and style guides for writing .proto files.

Introduction to ASP.NET Web Programming Using the Razor Syntax (C#)


What are protocol buffers?

Protocol buffers are a flexible, efficient, automated mechanism for serializing structured data – think XML, but smaller, faster, and simpler. You define how you want your data to be structured once, then you can use special generated source code to easily write and read your structured data to and from a variety of data streams and using a variety of languages. You can even update your data structure without breaking deployed programs that are compiled against the "old" format.

  By          Tom FitzMacken澳门新萄京官方网站,Tom FitzMacken|February 7, 2014

  1. DHTML(Dynamic HTML)
    DHTML is a collection of technologies used to move beyond the static presentation of information to create more interactive web pages. Technologies like JS, CSS, DOM play a role in the DHTML.

#1.FOR a software environment with a primarily statistical focus.

How do they work?

You specify how you want the information you're serializing to be structured by defining protocol buffer message types in .proto
files. Each protocol buffer message is a small logical record of information, containing a series of name-value pairs. Here's a very basic example of a .proto file that defines a message containing information about a person:

message Person { 
  required string name = 1; 
  required int32 id = 2; 
  optional string email = 3; 

  enum PhoneType { 
    MOBILE = 0; 
    HOME = 1; 
    WORK = 2; 

  message PhoneNumber { 
    required string number = 1; 
    optional PhoneType type = 2 [default = HOME]; 

  repeated PhoneNumber phone = 4;

As you can see, the message format is simple – each message type has one or more uniquely numbered fields, and each field has a name and a value type, where value types can be numbers (integer or floating-point), booleans, strings, raw bytes, or even (as in the example above) other protocol buffer message types, allowing you to structure your data hierarchically. You can specify optional fields, required fields, and repeated fields. You can find more information about writing.proto
files in the Protocol Buffer Language Guide.
Once you've defined your messages, you run the protocol buffer compiler for your application's language on your .proto file to generate data access classes. These provide simple accessors for each field (like name() and set_name()) as well as methods to serialize/parse the whole structure to/from raw bytes – so, for instance, if your chosen language is C , running the compiler on the above example will generate a class called Person. You can then use this class in your application to populate, serialize, and retrieve Person protocol buffer messages. You might then write some code like this:

Person person;
person.set_name("John Doe");
fstream output("myfile", ios::out | ios::binary);

Then, later on, you could read your message back in:

fstream input("myfile", ios::in | ios::binary);
Person person;
cout << "Name: " << person.name() << endl;
cout << "E-mail: " << person.email() << endl;

You can add new fields to your message formats without breaking backwards-compatibility; old binaries simply ignore the new field when parsing. So if you have a communications protocol that uses protocol buffers as its data format, you can extend your protocol without having to worry about breaking existing code.

You'll find a complete reference for using generated protocol buffer code in the API Reference section, and you can find out more about how protocol buffer messages are encoded in Protocol Buffer Encoding.

1751 of 1904 people found this helpful

29.Progressive rendering is the name given to techniques used to render content for display as quickly as possible.

#2.there will be an amazing visual work.

Why not just use XML?

Protocol buffers have many advantages over XML for serializing structured data. Protocol buffers:

  • are simpler
  • are 3 to 10 times smaller
  • are 20 to 100 times faster
  • are less ambiguous
  • generate data access classes that are easier to use programmatically

For example, let's say you want to model a person with a name and an email. In XML, you need to do:

  <name>John Doe</name>

while the corresponding protocol buffer message (in protocol buffer text format) is:

# Textual representation of a protocol buffer.
# This is *not* the binary format used on the wire.
person { 
  name: "John Doe" 
  email: "jdoe@example.com"

When this message is encoded to the protocol buffer binary format (the text format above is just a convenient human-readable representation for debugging and editing), it would probably be 28 bytes long and take around 100-200 nanoseconds to parse. The XML version is at least 69 bytes if you remove whitespace, and would take around 5,000-10,000 nanoseconds to parse.

Also, manipulating a protocol buffer is much easier:

  cout << "Name: " << person.name() << endl;  
  cout << "E-mail: " << person.email() << endl;

Whereas with XML you would have to do something like:

    cout << "Name: "
            << person.getElementsByTagName("name")->item(0)->innerText()       
            << endl;  
    cout << "E-mail: "       
            << person.getElementsByTagName("email")->item(0)->innerText()       
            << endl;

However, protocol buffers are not always a better solution than XML – for instance, protocol buffers would not be a good way to model a text-based document with markup (e.g. HTML), since you cannot easily interleave structure with text. In addition, XML is human-readable and human-editable; protocol buffers, at least in their native format, are not. XML is also – to some extent – self-describing. A protocol buffer is only meaningful if you have the message definition (the .proto file).


It used to be much more prevalent in the days before broadband internet but it's still useful in modern development as mobile data connections are becoming increasingly popular (and unreliable!)

#May be a complete set of operational procedures.

Sounds like the solution for me! How do I get started?

Download the package – this contains the complete source code for the Java, Python, and C protocol buffer compilers, as well as the classes you need for I/O and testing. To build and install your compiler, follow the instructions in the README.

Once you're all set, try following the tutorial for your chosen language – this will step you through creating a simple application that uses protocol buffers.


Examples of such techniques :

2.About basics.

Introducing proto3

Our most recent version 3 release introduces a new language version - Protocol Buffers language version 3 (aka proto3), as well as some new features in our existing language version (aka proto2). Proto3 simplifies the protocol buffer language, both for ease of use and to make it available in a wider range of programming languages: our current release lets you generate protocol buffer code in Java, C , Python, Java Lite, Ruby, JavaScript, Objective-C, and C#. In addition you can generate proto3 code for Go using the latest Go protoc plugin, available from thegolang/protobuf Github repository. More languages are in the pipeline.

We currently recommend trying proto3 only:

  • If you want to try using protocol buffers in one of our newly-supported languages.
  • If you want to try our new open-source RPC implementation gRPC – we recommend using proto3 for all new gRPC servers and clients as it avoids compatibility issues.

Note that the two language version APIs are not completely compatible. To avoid inconvenience to existing users, we will continue to support the previous language version in new protocol buffers releases.

You can see the major differences from the current default version in the release notes and learn about proto3 syntax in the Proto3 Language Guide. Full documentation for proto3 is coming soon!

(If the names proto2 and proto3 seem a little confusing, it's because when we originally open-sourced protocol buffers it was actually Google's second version of the language – also known as proto2. This is also why our open source version number started from v2.0.0).

This article gives you an overview of programming with ASP.NET Web Pages using the Razor syntax. ASP.NET is Microsoft's technology for running dynamic web pages on web servers. This articles focuses on using the C# programming language.

Lazy loading of images where (typically) some javascript will load an image when it comes into the browsers viewport instead of loading all images at page load.
Prioritizing visible content (or above the fold rendering) where you include only the minimum css/content/scripts necessary for the amount of page that would be rendered in the users browser first to display as quickly as possible, you can then use deferred javascript (domready/load) to load in other resources and content.

we need threw ourselves into the preparation with some basic knowledge of HTML, XML and the logic of regular expressions and Xpath, BUT the operations are executed from WIHTIN R!

A bit of history

Protocol buffers were initially developed at Google to deal with an index server request/response protocol. Prior to protocol buffers, there was a format for requests and responses that used hand marshalling/unmarshalling of requests and responses, and that supported a number of versions of the protocol. This resulted in some very ugly code, like:

 if (version == 3) {   
} else if (version > 4) {   
    if (version == 5) {     
    }   ... 

Explicitly formatted protocols also complicated the rollout of new protocol versions, because developers had to make sure that all servers between the originator of the request and the actual server handling the request understood the new protocol before they could flip a switch to start using the new protocol.

Protocol buffers were designed to solve many of these problems:

  • New fields could be easily introduced, and intermediate servers that didn't need to inspect the data could simply parse it and pass through the data without needing to know about all the fields.
  • Formats were more self-describing, and could be dealt with from a variety of languages (C , Java, etc.)

However, users still needed to hand-write their own parsing code.

As the system evolved, it acquired a number of other features and uses:

  • Automatically-generated serialization and deserialization code avoided the need for hand parsing.
  • In addition to being used for short-lived RPC (Remote Procedure Call) requests, people started to use protocol buffers as a handy self-describing format for storing data persistently (for example, in Bigtable).
  • Server RPC interfaces started to be declared as part of protocol files, with the protocol compiler generating stub classes that users could override with actual implementations of the server's interface.

Protocol buffers are now Google's lingua franca for data – at time of writing, there are 48,162 different message types defined in the Google code tree across 12,183 .proto files. They're used both in RPC systems and for persistent storage of data in a variety of storage systems.

What you'll learn:


  • The top 8 programming tips for getting started with programming ASP.NET Web Pages using Razor syntax.
  • Basic programming concepts you'll need.
  • What ASP.NET server code and the Razor syntax is all about.

Software versions

  • ASP.NET Web Pages (Razor) 3

This tutorial also works with ASP.NET Web Pages 2.

4.A little case study.

The Top 8 Programming Tips

This section lists a few tips that you absolutely need to know as you start writing ASP.NET server code using the Razor syntax.

Note   The Razor syntax is based on the C# programming language, and that's the language that's used most often with ASP.NET Web Pages. However, the Razor syntax also supports the Visual Basic language, and everything you see you can also do in Visual Basic. For details, see  the appendix Visual Basic Language and Syntax.

You can find more details about most of these programming techniques later in the article.

#htmlParse()用来interpreting HTML
                        encoding = "UTF-8")
#the next step:extract tables/data
#readHTMLTable() for identifying and reading out those tables
#so we got an "list" format#

1. You add code to a page using the @ character

The @ character starts inline expressions, single statement blocks, and multi-statement blocks:

<!-- Single statement blocks  -->
@{ var total = 7; }
@{ var myMessage = "Hello World"; }

<!-- Inline expressions -->
<p>The value of your account is: @total </p>
<p>The value of myMessage is: @myMessage</p>

<!-- Multi-statement block -->
    var greeting = "Welcome to our site!";
    var weekDay = DateTime.Now.DayOfWeek;
    var greetingMessage = greeting   " Today is: "   weekDay;
<p>The greeting is: @greetingMessage</p>

This is what these statements look like when the page runs in a browser:

澳门新萄京官方网站 1


HTML Encoding

When you display content in a page using the @ character, as in the preceding examples, ASP.NET HTML-encodes the output. This replaces reserved HTML characters (such as < and > and &) with codes that enable the  characters to be displayed as characters in a web page instead of being interpreted as HTML tags or entities. Without HTML encoding, the output from your server code might not display correctly, and could expose a page to security risks.

If your goal is to output HTML markup that renders tags as markup (for example <p></p> for a paragraph or <em></em> to emphasize text), see the section Combining Text, Markup, and Code in Code Blocks later in this article.

You can read more about HTML encoding in Working with Forms.

因为昂科威对于华语的扶助不是很好,所以遭遇一些华语乱码是常规的,所以我们须求more advanced text manipulation tools.(本例中冒出了部分列音信的一心不见是因为该网址的少数列的多寡是以.png格式放置的。)

2. You enclose code blocks in braces

A code block includes one or more code statements and is enclosed in braces.

<!-- Single statement block.  -->
@{ var theMonth = DateTime.Now.Month; }
<p>The numeric value of the current month: @theMonth</p>

<!-- Multi-statement block. -->
    var outsideTemp = 79;
    var weatherMessage = "Hello, it is "   outsideTemp   " degrees.";
<p>Today's weather: @weatherMessage</p>

The result displayed in a browser:

澳门新萄京官方网站 2

5.ABC's of...

3. Inside a block, you end each code statement with a semicolon

Inside a code block, each complete code statement must end with a semicolon. Inline expressions don't end with a semicolon.

<!-- Single-statement block -->
@{ var theMonth = DateTime.Now.Month; }

<!-- Multi-statement block -->
    var outsideTemp = 79;
    var weatherMessage = "Hello, it is "   outsideTemp   " degrees.";

<!-- Inline expression, so no semicolon -->
<p>Today's weather: @weatherMessage</p>

For browsing the Web, there is a hidden standard behind the scenes that structures how information is displayed.

4. You use variables to store values

You can store values in a variable, including strings, numbers, and dates, etc. You create a new variable using the var keyword. You can insert variable values directly in a page using @.

<!-- Storing a string -->
@{ var welcomeMessage = "Welcome, new members!"; }

<!-- Storing a date -->
@{ var year = DateTime.Now.Year; }

<!-- Displaying a variable -->
<p>Welcome to our new members who joined in @year!</p>

The result displayed in a browser:

澳门新萄京官方网站 3

#HTML or the hypertext markup language

5. You enclose literal string values in double quotation marks

A string is a sequence of characters that are treated as text. To specify a string, you enclose it in double quotation marks:

@{ var myString = "This is a string literal"; }

If the string that you want to display contains a backslash character () or double quotation marks  ( " ), use a verbatim string literal that's prefixed with the @ operator. (In C#, the character has special meaning unless you use a verbatim string literal.)

<!-- Embedding a backslash in a string -->
@{ var myFilePath = @"C:MyFolder"; }
<p>The path is: @myFilePath</p>

To embed double quotation marks, use a verbatim string literal and repeat the quotation marks:

<!-- Embedding double quotation marks in a string -->
@{ var myQuote = @"The person said: ""Hello, today is Monday."""; }

Here's the result of using both of these examples in a page:

澳门新萄京官方网站 4

Note   Notice that the @ character is used both to mark verbatim string literals in C# and to mark code in ASP.NET pages. 

Not a dedicated data storage format, but usually contains the useful information. And in general HTML is used to shape the display of information.

6. Code is case sensitive

In C#, keywords (like var, true, and if) and variable names are case sensitive. The following lines of code create two different variables, lastName and LastName.

    var lastName = "Smith";
    var LastName = "Jones";

If you declare a variable as var lastName = "Smith"; and if you try to reference that variable in your page as @LastName, an error results because LastName won't be recognized.

Note   In Visual Basic, keywords and variables are not case sensitive.

#XML the extensible markup language or XML

7. Much of your coding involves objects

An object represents a thing that you can program with — a page, a text box, a file, an image, a web request, an email message, a customer record (database row), etc. Objects have properties that describe their characteristics and that you  can read or change — a text box object has a Text property (among others), a request object has a Url property, an email message has a From property, and a customer object has a FirstName property. Objects also have methods that are the "verbs" they can perform. Examples include a file object's Save method, an image object's Rotate method, and an email object's Send method.

You'll often work with the Request object, which gives you information like the values of text boxes (form fields) on the page, what type of browser made the request, the URL of the page, the user identity, etc. The following example shows how to access properties of the Request object and how to call the MapPath method of the Request object, which gives you the absolute path of the page on the server:

<table border="1">
    <td>Requested URL</td>
    <td>Relative Path</td>
    <td>Full Path</td>
    <td>HTTP Request Type</td>

The result displayed in a browser:

澳门新萄京官方网站 5

The main purpose of XML is to storage data. Thus HTML documents are interpreted and transformed in to pretty-looking output by browsers, whereas XML is "just" data wrapped in user-defined tags. The user-defined tags make XML much more flexible for storing data than HTML. Both HTML and XML-style document offer natrual, often hierarchical, structures for data storage. 

8. You can write code that makes decisions

A key feature of dynamic web pages is that you can determine what to do based on conditions. The most common way to do this is with theif statement (and optional else statement).

   var result = "";
      result = "This page was posted using the Submit button.";
      result = "This was the first request for this page.";

<!DOCTYPE html>
<form method="POST" action="" >
  <input type="Submit" name="Submit" value="Submit"/>

The statement if(IsPost) is a shorthand way of writing if(IsPost == true). Along with if statements, there are a variety of ways to test conditions, repeat blocks of code, and so on, which are described later in this article.

The result displayed in a browser (after clicking Submit):

澳门新萄京官方网站 6


HTTP GET and POST Methods and the IsPost Property

The protocol used for web pages (HTTP) supports a very limited number of methods (verbs) that are used to make requests to the server. The two most common ones are GET, which is used to read a page, and POST, which is used to submit a page. In general, the first time a user requests a page, the page is requested using GET. If the user fills in a form and then clicks a submit button, the browser makes a POST request to the server.

In web programming, it's often useful to know whether a page is being requested as a GET or as a POST so that you know how to process the page. In ASP.NET Web Pages, you can use the IsPost property to see whether a request is a GET or a POST. If the request is a POST, the IsPost property will return true, and you can do things like read the values of text boxes on a form. Many examples you'll see show you how to process the page differently depending on the value of IsPost.

#JSON or JavaScript Object Notation

A Simple Code Example

This procedure shows you how to create a page that illustrates basic programming techniques. In the example, you create a page that lets users enter two numbers, then it adds them and displays the result.

  1. In your editor, create a new file and name it AddNumbers.cshtml.
  2. Copy the following code and markup into the page, replacing anything already in the page.

        var total = 0;
        var totalMessage = "";
        if(IsPost) {
            // Retrieve the numbers that the user entered.
            var num1 = Request["text1"];
            var num2 = Request["text2"];
            // Convert the entered strings into integers numbers and add.
            total = num1.AsInt()   num2.AsInt();
            totalMessage = "Total = "   total;
    <!DOCTYPE html>
    <html lang="en">
        <title>Add Numbers</title>
        <meta charset="utf-8" />
        <style type="text/css">
          body {background-color: beige; font-family: Verdana, Arial;
                margin: 50px; }
          form {padding: 10px; border-style: solid; width: 250px;}
      <p>Enter two whole numbers and then click <strong>Add</strong>.</p>
      <form action="" method="post">
        <p><label for="text1">First Number:</label>
          <input type="text" name="text1" />
        <p><label for="text2">Second Number:</label>
          <input type="text" name="text2" />
        <p><input type="submit" value="Add" /></p>

    Here are some things for you to note:

    • The @ character starts the first block of code in the page, and it precedes the totalMessage variable that's embedded near the bottom of the page.

    • The block at the top of the page is enclosed in braces.

    • In the block at the top, all lines end with a semicolon.

    • The variables total, num1, num2, and totalMessage store several numbers and a string.

    • The literal string value assigned to the totalMessage variable is in double quotation marks.

    • Because the code is case-sensitive, when the totalMessage variable is used near the bottom of the page, its name must match the variable at the top exactly.

    • The expression num1.AsInt()   num2.AsInt() shows how to work with objects and methods. The AsInt method on each variable converts the string entered by a user to a number (an integer) so that you can perform arithmetic on it.

    • The <form> tag includes a method="post" attribute. This specifies  that when the user clicks Add, the page will be sent to the server using the HTTP POST method. When the page is submitted, the if(IsPost) test evaluates to true and the conditional code runs, displaying the result of adding the numbers.

  3. Save the page and run it in a browser. (Make sure the page is selected in the Files workspace before you run it.) Enter two whole numbers and then click the Add button.

    澳门新萄京官方网站 7


Basic Programming Concepts

This article provides you with an overview of ASP.NET web programming. It isn't an exhaustive examination, just a quick tour through the programming concepts you'll use most often. Even so, it covers almost everything you'll need to get started  with ASP.NET Web Pages.

But first, a little technical background.

#AJAX or "Asynchronous JavaScript and XML"

The Razor Syntax, Server Code, and ASP.NET

Razor syntax is a simple programming syntax for embedding server-based code in a web page. In a web page that uses the Razor syntax, there are two kinds of content: client content and server code. Client content is the stuff you're used to in web pages: HTML markup (elements), style information such as CSS, maybe some client script such as JavaScript, and plain text.

Razor syntax lets you add server code to this client content. If there's server code in the page, the server runs that code first, before it sends the page to the browser. By running on the server, the code can perform tasks that can be a lot more complex to do using client content alone, like accessing server-based databases. Most importantly, server code can dynamically create client content — it can generate HTML markup or other content on the fly and then send it to the browser along with any static HTML that the page might contain. From the browser's perspective, client content that's generated by your server code is no different than any other client content. As you've already seen, the server code that's required is quite simple.

ASP.NET web pages that include the Razor syntax have a special file extension (.cshtml or .vbhtml). The server recognizes these extensions, runs the code that's marked with Razor syntax, and then sends the page to the browser.


Where does ASP.NET fit in?

Razor syntax is based on a technology from Microsoft called ASP.NET, which in turn is based on the Microsoft .NET Framework. The.NET Framework is a big, comprehensive programming framework from Microsoft for developing virtually any type of computer application. ASP.NET is the part of the .NET Framework that's specifically designed for creating web applications. Developers have used ASP.NET to create many of the largest and highest-traffic websites in the world. (Any time you see the file-name extension .aspx as part of the URL in a site, you'll know that the site was written using ASP.NET.)

The Razor syntax gives you all the power of ASP.NET, but using a simplified syntax that's easier to learn if you're a beginner and that makes you more productive if you're an expert. Even though this syntax is simple to use, its family relationship to ASP.NET and the .NET Framework means that as your websites become more sophisticated, you have the power of the larger frameworks available to you.

澳门新萄京官方网站 8

JSON JSON parsers
AJAX Selenuim
Plain text                Regular expressions

Classes and Instances

ASP.NET server code uses objects, which are in turn built on the idea of classes. The class is the definition or template for an object. For example, an application might contain a Customer class that defines the properties and methods that any customer object needs.

When the application needs to work with actual customer information, it creates an instance of (or instantiates) a customer object. Each individual customer is a separate instance of the Customer class. Every instance supports the same properties and methods, but the property values for each instance are typically different, because each customer object is unique. In one customer object, the LastName property might be "Smith"; in another customer object, the LastName property might be "Jones."

Similarly, any individual web page in your site is a Page object that's an instance of the Page class. A button on the page is a Button object that is an instance of the Button class, and so on. Each instance has its own characteristics, but they all are based on what's specified in the object's class definition.


Basic Syntax

Earlier you saw a basic example of how to create an ASP.NET Web Pages page, and how you can add server code to HTML markup. Here you'll learn the basics of writing ASP.NET server code using the Razor syntax — that is, the programming language rules.

If you're experienced with programming (especially if you've used C, C , C#, Visual Basic, or JavaScript), much of what you read here will be familiar. You'll probably need to familiarize yourself only with how server code is added to markup in .cshtml files.

Combining Text, Markup, and Code in Code Blocks

In server code blocks, you often want to output text or markup (or both) to the page. If a server code block contains text that's not code and that instead should be rendered as is, ASP.NET needs to be able to distinguish that text from code. There are several ways to do this.

  • Enclose the text in an HTML element like <p></p> or <em></em>:

    @if(IsPost) {
        // This line has all content between matched <p> tags.
        <p>Hello, the time is @DateTime.Now and this page is a postback!</p>
    } else {
        // All content between matched tags, followed by server code.
        <p>Hello <em>stranger</em>, today is: <br /> </p>  @DateTime.Now

    The HTML element can include text, additional HTML elements, and server-code expressions. When ASP.NET sees the opening HTML tag (for example, <p>), it renders everything including the element and its content as is to the browser, resolving server-code expressions as it goes.

  • Use the @: operator or the <text> element. The @: outputs a single line of content containing plain text or unmatched HTML tags; the <text> element encloses multiple lines to output. These options are useful when you don't want to render an HTML element as part of the output.

    @if(IsPost) {
        // Plain text followed by an unmatched HTML tag and server code.
        @: The time is: <br /> @DateTime.Now
        // Server code and then plain text, matched tags, and more text.
        @DateTime.Now @:is the <em>current</em> time.

    If you want to output multiple lines of text or unmatched HTML tags, you can precede each line with @:, or you can enclose the line in a <text> element. Like the @: operator,<text> tags are used by ASP.NET to identify text content and are never rendered in the page output.

    @if(IsPost) {
        // Repeat the previous example, but use <text> tags.
        The time is: <br /> @DateTime.Now
        @DateTime.Now is the <em>current</em> time.
        var minTemp = 75;
        <text>It is the month of @DateTime.Now.ToString("MMMM"), and
        it's a <em>great</em> day! <br /><p>You can go swimming if it's at
        least @minTemp degrees. </p></text>

    The first example repeats the previous example but uses a single pair of <text> tags to enclose the text to render. In the second example, the <text> and </text> tags enclose three lines, all of which have some uncontained text and unmatched HTML tags (<br />), along with server code and matched HTML tags. Again, you could also precede each line individually with the @: operator; either way works.

    Note   When you output text as shown in this section — using an HTML element, the @: operator, or the <text> element — ASP.NET doesn't HTML-encode the output. (As noted earlier, ASP.NET does encode the output of server code expressions and server code blocks that are preceded by @, except in the special cases noted in this section.)


Extra spaces in a statement (and outside of a string literal) don't affect the statement:

@{ var lastName =    "Smith"; }

A line break in a statement has no effect on the statement, and you can wrap statements for readability. The following statements are the same:

@{ var theName =
"Smith"; }


However, you can't wrap a line in the middle of a string literal. The following example doesn't  work:

@{ var test = "This is a long
    string"; }  // Does not work!

To combine a long string that wraps to multiple lines like the above code, there are two options. You can use the concatenation operator ( ), which you'll see later in this article. You can also use the @ character to create a verbatim string literal, as you saw earlier in this article. You can break verbatim string literals across lines:

@{ var longString = @"This is a

Code (and Markup) Comments

Comments let you leave notes for yourself or others. They also allow you to disable (comment out) a section of code or markup that you don't want to run but want to keep in your page for the time being.

There's different commenting syntax for Razor code and for HTML markup. As with all Razor code, Razor comments are processed (and then removed) on the server before the page is sent to the browser. Therefore, the Razor commenting syntax lets you put comments into the code (or even into the markup) that you can see when you edit the file, but that users don't see, even in the page source.

For ASP.NET Razor comments, you start the comment with @* and end it with *@. The comment can be on one line or multiple lines:

@*  A one-line code comment. *@

    This is a multiline code comment.
    It can continue for any number of lines.

Here is a comment within a code block:

    @* This is a comment. *@
    var theVar = 17;

Here is the same block of code, with the line of code commented out so that it won't run:

    @* This is a comment. *@
    @* var theVar = 17;  *@

Inside a code block, as an alternative to using Razor comment syntax, you can use the commenting syntax of the programming language you're using, such as C#:

    // This is a comment.
    var myVar = 17;
    /* This is a multi-line comment
    that uses C# commenting syntax. */

In C#, single-line comments are preceded by the // characters, and multi-line comments begin with /* and end with */. (As with Razor comments, C# comments are not rendered to the browser.)

For markup, as you probably know, you can create an HTML comment:

<!-- This is a comment.  -->

HTML comments start with <!-- characters and end with -->. You can use HTML comments to surround not only text, but also any HTML markup that you may want to keep in the page but don't want to render. This HTML comment will hide the entire content of the tags and the text they contain:

<!-- <p>This is my paragraph.</p>  -->

Unlike Razor comments, HTML comments are rendered to the page and the user can see them by viewing the page source.

Razor has limitations on nested blocks of C#. For more information see  Named C# Variables and Nested Blocks Generate Broken Code


A variable is a named object that you use to store data. You can name variables anything, but the name must begin with an alphabetic character and it cannot contain whitespace or reserved characters.

Variables and Data Types

A variable can have a specific data type, which indicates what kind of data is stored in the variable. You can have string variables that store string values (like "Hello world"), integer variables that store whole-number values (like 3 or 79), and date variables that store date values in a variety of formats (like 4/12/2012 or March 2009). And there are many other data types you can use.

However, you generally don't have to specify a type for a variable. Most of the time, ASP.NET can figure out the type based on how the data in the variable is being used. (Occasionally you must specify a type; you'll see examples where this is true.)

You declare a variable using the var keyword (if you don't want to specify a type) or by using the name of the type:

    // Assigning a string to a variable.
    var greeting = "Welcome!";

    // Assigning a number to a variable.
    var theCount = 3;

    // Assigning an expression to a variable.
    var monthlyTotal = theCount   5;

    // Assigning a date value to a variable.
    var today = DateTime.Today;

    // Assigning the current page's URL to a variable.
    var myPath = this.Request.Url;

    // Declaring variables using explicit data types.
    string name = "Joe";
    int count = 5;
    DateTime tomorrow = DateTime.Now.AddDays(1);

The following example shows some typical uses of variables in a web page:

    // Embedding the value of a variable into HTML markup.
    <p>@greeting, friends!</p>

    // Using variables as part of an inline expression.
    <p>The predicted annual total is: @( monthlyTotal * 12)</p>

    // Displaying the page URL with a variable.
    <p>The URL to this page is: @myPath</p>

If you combine the previous examples in a page, you see this displayed in a browser:

澳门新萄京官方网站 9

Converting and Testing Data Types

Although ASP.NET can usually determine a data type automatically, sometimes it can't. Therefore, you might need to help ASP.NET out by performing an explicit conversion. Even if you don't have to convert types, sometimes it's helpful to test to see what type of data you might be working with.

The most common case is that you have to convert a string to another type, such as to an integer or date. The following example shows a typical case where you must convert a string to a number.

    var total = 0;

    if(IsPost) {
        // Retrieve the numbers that the user entered.
        var num1 = Request["text1"];
        var num2 = Request["text2"];
        // Convert the entered strings into integers numbers and add.
        total = num1.AsInt()   num2.AsInt();

As a rule, user input comes to you as strings. Even if you've prompted users to enter a number, and even if they've entered a digit, when user input is submitted and you read it in code, the data is in string format. Therefore, you must convert the string to a number. In the example, if you try to perform arithmetic on the values without converting them, the following error results, because ASP.NET cannot add two strings:

Cannot implicitly convert type 'string' to 'int'.

To convert the values to integers, you call the AsInt method. If the conversion is successful, you can then add the numbers.

The following table lists some common conversion and test methods for variables.




AsInt(), IsInt()

Converts a string that represents a whole number (like "593") to an integer.

var myIntNumber = 0;
var myStringNum = "539";
    myIntNumber = myStringNum.AsInt();

AsBool(), IsBool()

Converts a string like "true" or "false" to a Boolean type.

var myStringBool = "True";
var myVar = myStringBool.AsBool();

AsFloat(), IsFloat()

Converts a string that has a decimal value like "1.3" or "7.439" to a floating-point number.

var myStringFloat = "41.432895";
var myFloatNum = myStringFloat.AsFloat();

AsDecimal(), IsDecimal()

Converts a string that has a decimal value like "1.3" or "7.439" to a decimal number. (In ASP.NET, a decimal number is more precise than a floating-point number.)

var myStringDec = "10317.425";
var myDecNum = myStringDec.AsDecimal();

AsDateTime(), IsDateTime()

Converts a string that represents a date and time value to the ASP.NET DateTime type.

var myDateString = "12/27/2012";
var newDate = myDateString.AsDateTime();


Converts any other data type to a string.

int num1 = 17;
int num2 = 76;
// myString is set to 1776
string myString = num1.ToString()  


An operator is a keyword or character that tells ASP.NET what kind of command to perform in an expression. The C# language (and the Razor syntax that's based on it) supports many operators, but you only need to recognize a few to get started. The following table summarizes the most common operators.




- * /

Math operators used in numerical expressions.

@(5   13)
@{ var netWorth = 150000; }
@{ var newTotal = netWorth * 2; }
@(newTotal / 2)


Assignment. Assigns the value on the right side of a statement to the object on the left side.

var age = 17;


Equality. Returns true if the values are equal. (Notice the distinction between the = operator and the == operator.)

var myNum = 15;
if (myNum == 15) {
    // Do something.


Inequality. Returns true if the values are not equal.

var theNum = 13;
if (theNum != 15) {
    // Do something.

< >  <= >=

Less-than, greater-than, less-than-or-equal, and greater-than-or-equal.

if (2 < 3) {
    // Do something.
var currentCount = 12;
if(currentCount >= 12) {
    // Do something.

Concatenation, which is used to join strings. ASP.NET knows the difference between this operator and the addition operator based on the data type of the expression.

// The displayed result is "abcdef".
@("abc"   "def")



The increment and decrement operators, which add and subtract 1 (respectively) from a variable.

int theCount = 0;
theCount  = 1; // Adds 1 to count


Dot. Used to distinguish objects and their properties and methods.

var myUrl = Request.Url;
var count = Request["Count"].AsInt();


Parentheses. Used to group expressions and to pass parameters to methods.

@(3   7)


Brackets. Used for accessing values in arrays or collections.

var income = Request["AnnualIncome"];


Not. Reverses a true value to false and vice versa. Typically used as a shorthand way to test for false (that is, for not true).

bool taskCompleted = false;
// Processing.
if(!taskCompleted) {
    // Continue processing



Logical AND and OR, which are used to link conditions together.

bool myTaskCompleted = false;
int totalCount = 0;
// Processing.
if(!myTaskCompleted && totalCount < 12) {
    // Continue processing.

Working with File and Folder Paths in Code

You'll often work with file and folder paths in your code. Here is an example of physical folder structure for a website as it might appear on your development computer:

C:WebSitesMyWebSite     default.cshtml     datafile.txt     images         Logo.jpg     styles         Styles.css

 Here are some essential details about URLs and paths:

  • A URL begins with either a domain name () or a server  name (, ).
  • A URL corresponds to a physical  path on a host computer. For example, might correspond to the folder C:websitesmywebsite on  the server.
  • A virtual path is shorthand to represent  paths in code without having to specify the full path. It includes the portion  of a URL that follows the domain or server name. When you use virtual paths, you  can move your code to a different domain or server without having to update the  paths.

Here's an example to help you understand the differences:

Complete URL http://mycompanyserver/humanresources/CompanyPolicy.htm
Server name mycompanyserver
Virtual path /humanresources/CompanyPolicy.htm
Physical path C:mywebsiteshumanresourcesCompanyPolicy.htm

The virtual root is  /, just like the root of your C: drive is . (Virtual folder paths always use  forward slashes.) The virtual path of a folder doesn't have to have the same  name as the physical folder; it can be an alias. (On production servers, the  virtual path rarely matches an exact physical path.)

When you work with files and folders in code, sometimes you need to reference the physical path and sometimes a virtual path, depending on what objects you're working with. ASP.NET gives you these tools for working with file and folder paths in code: the Server.MapPath method, and the ~ operator and Href method.

Converting virtual to physical paths: the Server.MapPath method

The Server.MapPath method converts a virtual path (like /default.cshtml) to an absolute physical path (like C:WebSitesMyWebSiteFolderdefault.cshtml). You use this method  any time you need a complete physical path. A typical example is when you're reading or writing a text file  or image file on the web server.

You typically don't know the absolute physical path of your site on a hosting site's server, so this method can convert the path you do know —  the virtual path — to the corresponding path on the server for you. You pass the virtual path to a file or folder to the method, and it returns the physical path:

    var dataFilePath = "~/dataFile.txt";
<!-- Displays a physical path C:WebsitesMyWebSitedatafile.txt  -->

Referencing the virtual root: the ~ operator and Href method

In a .cshtml or .vbhtml file, you can reference the virtual root path  using the ~ operator. This is very handy because you can move pages  around in a site, and any links they contain to other pages won't be broken.  It's also handy in case you ever move your website to a different location. Here are some examples:

    var myImagesFolder = "~/images";
    var myStyleSheet = "~/styles/StyleSheet.css";

If the website is , here's how ASP.NET will treat these paths when the page runs:

  • myImagesFolder:
  • myStyleSheet :

(You won't actually see these paths as the values of the variable, but ASP.NET will treat the paths as if that's what they were.)

You can use the ~ operator both in server code (as above) and in markup, like this:

<!-- Examples of using the ~ operator in markup in ASP.NET Web Pages -->

<a href="~/Default">Home</a>
<img src="~MyImages.png" />

In markup, you use the ~ operator to create paths to resources  like image files, other web pages, and CSS files. When the page runs, ASP.NET  looks through the page (both code and markup) and resolves all the ~ references to the appropriate path.

网页数据爬虫1。Conditional Logic and Loops

ASP.NET server code lets you perform tasks based on conditions and write code that repeats statements a specific number of times (that is, code that runs a loop).

Testing Conditions

To test a simple condition you use the if statement, which returns true or false based on a test you specify:

  var showToday = true;

The if keyword starts a block. The actual test (condition) is in parentheses and returns true or false. The statements that run if the test is true are enclosed in braces. An if statement can include an else block that specifies statements to run if the condition is false:

  var showToday = false;

You can add multiple conditions using an else if block:

    var theBalance = 4.99;
    if(theBalance == 0)
        <p>You have a zero balance.</p>
    else if (theBalance  > 0 && theBalance <= 5)
        <p>Your balance of $@theBalance is very low.</p>
        <p>Your balance is: $@theBalance</p>

In this example, if the first condition in the if block is not true, the else if condition is checked. If that condition is met, the statements in the else if block are executed. If none of the conditions are met, the statements in the else block are executed. You can add any number of else if blocks, and then close with an else block as the "everything else" condition.

To test a large number of conditions, use a switch block:

    var weekday = "Wednesday";
    var greeting = "";

        case "Monday":
            greeting = "Ok, it's a marvelous Monday";
        case "Tuesday":
            greeting = "It's a tremendous Tuesday";
        case "Wednesday":
            greeting = "Wild Wednesday is here!";
            greeting = "It's some other day, oh well.";

    <p>Since it is @weekday, the message for today is: @greeting</p>

The value to test is in parentheses (in the example, the weekday variable). Each individual test uses a case statement that ends with a colon (:). If the value of a case statement matches the test value, the code in that case block is executed. You close each case statement with a break statement. (If you forget to include break in each case block, the code from the next case statement will run also.) A switch block often has a default statement as the last case for an "everything else" option that runs if none of the other cases are true.

The result of the last two conditional blocks displayed in a browser:

澳门新萄京官方网站 10

Looping Code

You often need to run the same statements repeatedly. You do this by looping. For example, you often run the same statements for each item in a collection of data. If you know exactly how many times you want to loop, you can use a for loop. This kind of loop is especially useful for counting up or counting down:

@for(var i = 10; i < 21; i  )
    <p>Line #: @i</p>

The loop begins with the for keyword, followed by three statements in parentheses, each terminated with a semicolon.

  • Inside the parentheses, the first statement (var i=10;) creates a counter and initializes it to 10. You don't have to name the counter i — you can use any variable. When the for loop runs, the counter is automatically incremented.
  • The second statement (i < 21;) sets the condition for how far you want to count. In this case, you want it to go to a maximum of 20 (that is, keep going while the counter is less than 21).
  • The third statement (i ) uses an increment operator, which simply specifies that the counter should have 1 added to it each time the loop runs.

Inside the braces is the code that will run for each iteration of the loop. The markup creates a new paragraph (<p> element) each time and  adds a line to the output,  displaying the value of i (the counter). When you run this page, the example creates 11 lines displaying the output, with the text in each line indicating the item  number.

澳门新萄京官方网站 11


If you're working with a collection or array, you often use a foreach loop. A collection is a group of similar objects, and the foreach loop lets you carry out a task on each item in the collection. This type of loop is convenient for collections, because unlike a for loop, you don't have to increment the counter or set a limit. Instead, the foreach loop code simply proceeds through the collection until it's finished.

For example, the following code returns the items in the Request.ServerVariables collection, which is an object that contains information about your web server. It uses a foreach loop to display the name of each item by creating a new <li> element in an HTML bulleted list.

@foreach (var myItem in Request.ServerVariables)

The foreach keyword is followed by parentheses where you declare a variable that represents a single item in the collection (in the example, var item), followed by the in keyword, followed by the collection you want to loop through. In the body of the foreach loop, you can access the current item using the variable that you declared earlier.

澳门新萄京官方网站 12

To create a more general-purpose loop, use the while statement:

    var countNum = 0;
    while (countNum < 50)
        countNum  = 1;
        <p>Line #@countNum: </p>

A while loop begins with the while keyword, followed by parentheses where you specify how long the loop continues (here, for as long as countNum is less than 50), then the block to repeat. Loops typically increment (add to) or decrement (subtract from) a variable or object used for counting. In the example, the = operator adds 1 to countNum each time the loop runs. (To decrement a variable in a loop that counts down, you would use the decrement operator -=).

Objects and Collections

Nearly everything in an ASP.NET website is an object, including the web page itself. This section discusses some important objects you'll work with frequently in your code.

Page Objects

The most basic object in ASP.NET is the page. You can access properties of the page object directly without any qualifying object. The following code gets the page's file path, using the Request object of the page:

    var path = Request.FilePath;

To make it clear that you're referencing properties and methods on the current page object, you can optionally use the keyword this to represent the page object in your code. Here is the previous code example, with this added to represent the page:

    var path = this.Request.FilePath;

You can use properties of the Page object to get a lot of information, such as:

  • Request. As you've already seen, this is a collection of information about the current request, including what type of browser made the request, the URL of the page, the user identity, etc.
  • Response. This is a collection of information about the response (page) that will be sent to the browser when the server code has finished running. For example, you can use this property to write information into the response.

        // Access the page's Request object to retrieve the Url.
        var pageUrl = this.Request.Url;
    <a href="@pageUrl">My page</a>

Collection Objects (Arrays and Dictionaries)

A collection is a group of objects of the same type, such as a collection of Customer objects from a database. ASP.NET contains many built-in collections, like the Request.Files collection.

You'll often work with data in collections. Two common collection types are the array and the dictionary. An array is useful when you want to store a collection of similar items but don't want to create a separate variable to hold each item:

@* Array block 1: Declaring a new array using braces. *@
    <h3>Team Members</h3>
    string[] teamMembers = {"Matt", "Joanne", "Robert", "Nancy"};
    foreach (var person in teamMembers)

With arrays, you declare a specific data type, such as string, int, or DateTime. To indicate that the variable can contain an array, you add brackets to the declaration (such as string[] or int[]). You can access items in an array using their position (index) or by using the foreach statement. Array indexes are zero-based — that is, the first item is at position 0, the second item is at position 1, and so on.

    string[] teamMembers = {"Matt", "Joanne", "Robert", "Nancy"};
    <p>The number of names in the teamMembers array: @teamMembers.Length </p>
    <p>Robert is now in position: @Array.IndexOf(teamMembers, "Robert")</p>
    <p>The array item at position 2 (zero-based) is @teamMembers[2]</p>
    <h3>Current order of team members in the list</h3>
    foreach (var name in teamMembers)
    <h3>Reversed order of team members in the list</h3>
    foreach (var reversedItem in teamMembers)

You can determine the number of items in an array by getting its Length property. To get the position of a specific item in the array (to search the array), use the Array.IndexOf method. You can also do things like reverse the contents of an array (the Array.Reverse method) or sort the contents (the Array.Sort method).

The output of the string array code displayed in a browser:

澳门新萄京官方网站 13

A dictionary is a collection of key/value pairs, where you provide the key (or name) to set or retrieve the corresponding value:

    var myScores = new Dictionary<string, int>();
    myScores.Add("test1", 71);
    myScores.Add("test2", 82);
    myScores.Add("test3", 100);
    myScores.Add("test4", 59);
<p>My score on test 3 is: @myScores["test3"]%</p>
@{myScores["test4"] = 79;}
<p>My corrected score on test 4 is: @myScores["test4"]%</p>

To create a dictionary, you use the new keyword to indicate that you're creating a new dictionary object. You can assign a dictionary to a variable using the var keyword. You indicate the data types of the items in the dictionary using angle brackets ( < > ). At the end of the declaration, you must add a pair of parentheses, because this is actually a method that creates a new dictionary.

To add items to the dictionary, you can call the Add method of the dictionary variable (myScores in this case), and then specify a key and a value. Alternatively, you can use square brackets to indicate the key and do a simple assignment, as in the following example:

myScores["test4"] = 79;

To get a value from the dictionary, you specify the key in brackets:

var testScoreThree = myScores["test3"];

Calling Methods with Parameters

As you read earlier in this article, the objects that you program with can have methods. For example, a Database object might have a Database.Connect method. Many methods also have one or more parameters. A parameter is a value that you pass to a method to enable the method to complete its task. For example, look at a declaration for the Request.MapPath method, which takes three parameters:

public string MapPath(string virtualPath, string baseVirtualDir, 
    bool allowCrossAppMapping);

(The line has been wrapped to make it more readable. Remember that you can  put line breaks almost any place except inside strings that are enclosed in  quotation marks.)

This method returns the physical path on the server that corresponds to a specified virtual path. The three parameters for the method are virtualPath, baseVirtualDir, and allowCrossAppMapping. (Notice that in the declaration, the parameters are listed with the data types of the data that they'll accept.) When you call this method, you must supply values for all three parameters.

The Razor syntax gives you two options for passing parameters to a method: positional parameters and  named parameters. To call a method using positional parameters, you pass the parameters in a strict order that's specified in the method declaration. (You would typically know this order by reading documentation for the method.) You must follow the order, and you can't skip any of the parameters — if necessary, you pass an empty string ("") or null for a positional parameter that you don't have a value for.

The following example assumes you have a folder named scripts on your website. The code calls the Request.MapPath method and passes values for the three parameters in the correct order. It then displays the resulting mapped path.

    // Pass parameters to a method using positional parameters.
    var myPathPositional = Request.MapPath("/scripts", "/", true);

When a method has many parameters, you can keep your code more readable by using named parameters. To call a method using named parameters, you specify the parameter name followed by a colon (:), and then the value. The advantage of named parameters is that you can pass them in any order you want. (A disadvantage is that the method call is not as compact.)

The following example calls the same method as above, but uses named parameters to supply the values:

    // Pass parameters to a method using named parameters.
    var myPathNamed = Request.MapPath(baseVirtualDir: "/", 
        allowCrossAppMapping: true, virtualPath: "/scripts");

As you can see, the parameters are passed in a different order. However, if you run the previous example and this example, they'll return the same value.

Handling Errors

Try-Catch Statements

You'll often have statements in your code that might fail for reasons outside your control. For example:

  • If your code tries to create or access a file, all sorts of errors might occur. The file you want might not exist, it might be locked, the code might not have permissions, and so on.

  • Similarly, if your code tries to update records in a database, there can be permissions issues, the connection to the database might be dropped, the data to save might be invalid, and so on.

In programming terms, these situations are called exceptions. If your code encounters an exception, it generates (throws) an error message that's, at best, annoying to users:

澳门新萄京官方网站 14

In situations where your code might encounter exceptions, and in order to avoid error messages of this type, you can use try/catch statements. In the try statement, you run the code that you're checking. In one or more catch statements, you can look for specific errors (specific types of exceptions) that might have occurred. You can include as many catch statements as you need to look for errors that you are anticipating.

Note   We recommend that you avoid using the Response.Redirect method  in try/catch statements, because it can cause an exception in your page.

The following example shows a page that creates a text file on the first request and then displays a button that lets the user open the file. The example deliberately uses a bad file name so that it will cause an exception. The code includes catch statements for two possible exceptions: FileNotFoundException, which occurs if the file name is bad, and DirectoryNotFoundException, which occurs if ASP.NET can't even find the folder. (You can uncomment a statement in the example in order to see how it runs when everything works properly.)

If your code didn't handle the exception, you would see an error page like the previous screen shot. However, the try/catch section helps prevent the user from seeing these types of errors.

    var dataFilePath = "~/dataFile.txt";
    var fileContents = "";
    var physicalPath = Server.MapPath(dataFilePath);
    var userMessage = "Hello world, the time is "   DateTime.Now;
    var userErrMsg = "";
    var errMsg = "";

        // When the user clicks the "Open File" button and posts
        // the page, try to open the created file for reading.
        try {
            // This code fails because of faulty path to the file.
            fileContents = File.ReadAllText(@"c:batafile.txt");

            // This code works. To eliminate error on page,
            // comment the above line of code and uncomment this one.
            //fileContents = File.ReadAllText(physicalPath);
        catch (FileNotFoundException ex) {
            // You can use the exception object for debugging, logging, etc.
            errMsg = ex.Message;
            // Create a friendly error message for users.
            userErrMsg = "A file could not be opened, please contact "
                  "your system administrator.";
        catch (DirectoryNotFoundException ex) {
            // Similar to previous exception.
            errMsg = ex.Message;
            userErrMsg = "A directory was not found, please contact "
                  "your system administrator.";
        // The first time the page is requested, create the text file.
        File.WriteAllText(physicalPath, userMessage);

<!DOCTYPE html>
<html lang="en">
        <meta charset="utf-8" />
        <title>Try-Catch Statements</title>
    <form method="POST" action="" >
      <input type="Submit" name="Submit" value="Open File"/>



Additional Resources

Programming with Visual Basic

Appendix: Visual Basic Language and Syntax

Reference Documentation


C# Language

This article was originally created on February 7, 2014