当前在线人数17964
首页 - 分类讨论区 - 电脑网络 - 窗口里的风景版 -阅读文章
未名交友
[更多]
[更多]
文章阅读:C#.Net Funsdamentals (6)
[同主题阅读] [版面: 窗口里的风景] [作者:cogt] , 2007年01月03日09:33:12
cogt
进入未名形象秀
我的博客
[上篇] [下篇] [同主题上篇] [同主题下篇]

发信人: cogt (苦荆茶), 信区: DotNet
标  题: C#.Net Funsdamentals (6)
发信站: BBS 未名空间站 (Wed Jan  3 09:33:36 2007), 转信

Introduction

C# (pronounced "C sharp") is a simple, modern, object-oriented, and type-
safe programming language. It will immediately be familiar to C and C++
programmers. C# combines the high productivity of Rapid Application
Development (RAD) languages and the raw power of C++.

Variables and parameters

Variables represent storage locations. Every variable has a type that
determines what values can be stored in the variable. Local variables are
variables that are declared in methods, properties, or indexers. A local
variable is defined by specifying a type name and a declarator that
specifies the variable name and an optional initial value, as in:

int a;
int b = 1;
but it is also possible for a local variable declaration to include multiple
declarators. The declarations of a and b can be rewritten as:

int a, b = 1;
A variable must be assigned before its value can be obtained. The example

class Test
{
  static void Main() {
     int a;
     int b = 1;
     int c = a + b;   // error, a not yet assigned
     ...
  }
}
results in a compile-time error because it attempts to use the variable a
before it is assigned a value.

A field  is a variable that is associated with a class or struct, or with an
instance of a class or struct. A field declared with the static modifier
defines a static variable, and a field declared without this modifier
defines an instance variable. A static field is associated with a type,
whereas an instance variable is associated with an instance. The example

using Personnel.Data;
class Employee
{
  private static DataSet ds;
  public string Name;
  public decimal Salary;
  ...
}
shows an Employee class that has a private static variable and two public
instance variables.

Formal parameter declarations also define variables. There are four kinds of
parameters: value parameters, reference parameters, output parameters, and
parameter arrays.

A value parameter is used for "in" parameter passing, in which the value of
an argument is passed into a method, and modifications of the parameter do
not impact the original argument. A value parameter refers to its own
variable, one that is distinct from the corresponding argument. This
variable is initialized by copying the value of the corresponding argument.
The example

using System;
class Test {
  static void F(int p) {
     Console.WriteLine("p = {0}", p);
     p++;
  }
  static void Main() {
     int a = 1;
     Console.WriteLine("pre:  a = {0}", a);
     F(a);
     Console.WriteLine("post: a = {0}", a);
  }
}
shows a method F that has a value parameter named p. The example produces
the output

pre:  a = 1
p = 1
post: a = 1
even though the value parameter p is modified.

A reference parameter is used for "by reference" parameter passing, in which
the parameter acts as an alias for a caller-provided argument. A reference
parameter does not itself define a variable, but rather refers to the
variable of the corresponding argument. Modifications of a reference
parameter impact the corresponding argument. A reference parameter is
declared with a ref modifier. The example

using System;
class Test {
  static void Swap(ref int a, ref int b) {
     int t = a;
     a = b;
     b = t;
  }
  static void Main() {
     int x = 1;
     int y = 2;

     Console.WriteLine("pre:  x = {0}, y = {1}", x, y);
     Swap(ref x, ref y);
     Console.WriteLine("post: x = {0}, y = {1}", x, y);
  }
}
shows a Swap method that has two reference parameters. The output produced
is:

pre:  x = 1, y = 2
post: x = 2, y = 1
The ref keyword must be used in both the declaration of the formal parameter
and in uses of it. The use of ref at the call site calls special attention
to the parameter so that a developer reading the code will understand that
the value of the argument could change as a result of the call.

An output parameter is similar to a reference parameter, except that the
initial value of the caller-provided argument is unimportant. An output
parameter is declared with an out modifier. The example

using System;
class Test {
  static void Divide(int a, int b, out int result, out int remainder) {
     result = a / b;
     remainder = a % b;
  }
  static void Main() {
     for (int i = 1; i < 10; i++)
        for (int j = 1; j < 10; j++) {
           int ans, r;
           Divide(i, j, out ans, out r);
           Console.WriteLine("{0} / {1} = {2}r{3}", i, j, ans, r);
        }
  }
}
shows a Divide method that includes two output parameters — one for the
result of the division and another for the remainder.

For value, reference, and output parameters, there is a one-to-one
correspondence between caller-provided arguments and the parameters used to
represent them. A parameter array enables a many-to-one relationship: many
arguments can be represented by a single parameter array. In other words,
parameter arrays enable variable length argument lists.

A parameter array is declared with a params modifier. There can be only one
parameter array for a given method, and it must always be the last parameter
specified. The type of a parameter array is always a single dimensional
array type. A caller can either pass a single argument of this array type,
or any number of arguments of the element type of this array type. For
instance, the example

using System;
class Test
{
  static void F(params int[] args) {
     Console.WriteLine("# of arguments: {0}", args.Length);
     for (int i = 0; i < args.Length; i++)
        Console.WriteLine("\targs[{0}] = {1}", i, args[i]);
  }
  static void Main() {
     F();
     F(1);
     F(1, 2);
     F(1, 2, 3);
     F(new int[] {1, 2, 3, 4});
  }
}
shows a method F that takes a variable number of int arguments, and several
invocations of this method. The output is:

# of arguments: 0
# of arguments: 1
  args[0] = 1
# of arguments: 2
  args[0] = 1
  args[1] = 2
# of arguments: 3
  args[0] = 1
  args[1] = 2
  args[2] = 3
# of arguments: 4
  args[0] = 1
  args[1] = 2
  args[2] = 3
  args[3] = 4
Most of the examples presented in this introduction use the WriteLine method
of the Console class. The argument substitution behavior of this method, as
exhibited in the example

int a = 1, b = 2;
Console.WriteLine("a = {0}, b = {1}", a, b);
is accomplished using a parameter array. The WriteLine method provides
several overloaded methods for the common cases in which a small number of
arguments are passed, and one method that uses a parameter array.

namespace System
{
  public class Console
  {
     public static void WriteLine(string s) {...}
     public static void WriteLine(string s, object a) {...}
     public static void WriteLine(string s, object a, object b) {...}
     ...
     public static void WriteLine(string s, params object[] args) {...}
  }
}

Summary


These will help u understand fundas of c#.net .. will continue

--

※ 来源:·BBS 未名空间站 mitbbs.com·[FROM: 216.99.]

[上篇] [下篇] [同主题上篇] [同主题下篇]
[转寄] [转贴] [回信给作者] [修改文章] [删除文章] [同主题阅读] [从此处展开] [返回版面] [快速返回] [收藏] [举报]
 
回复文章
标题:
内 容:

未名交友
将您的链接放在这儿

友情链接


 

Site Map - Contact Us - Terms and Conditions - Privacy Policy

版权所有,未名空间(mitbbs.com),since 1996