c#学习笔记 – 蜗牛的家

C# Parameter Modifiers
Parameter Modifier Meaning in Life
(None) If a parameter is not marked with a parameter modifier, it is assumed to be
passed by value, meaning the called method receives a copy of the original
data.
out Output parameters must be assigned by the method being called (and
therefore are passed by reference). If the called method fails to assign
output parameters, you are issued a compiler error.
ref The value is initially assigned by the caller and may be optionally reassigned
by the called method (as the data is also passed by reference). No compiler
error is generated if the called method fails to assign a ref parameter.
params This parameter modifier allows you to send in a variable number of
arguments as a single logical parameter. A method can have only a single
params modifier, and it must be the final parameter of the method.
To define a nullable variable type, the question mark symbol (?) is suffixed to the underlying
data type. Do note that this syntax is only legal when applied to value types. If you attempt to create
a nullable reference type (including strings), you are issued a compile-time error. Like a nonnullable
variable, local nullable variables must be assigned an initial value:
static void LocalNullableVariables()
{
// Define some local nullable types.
int? nullableInt = 10;
double? nullableDouble = 3.14;
bool? nullableBool = null;
char? nullableChar = ‘a’;
int?[] arrayOfNullableInts = new int?[10];
// Error! Strings are reference types!
// string? s = "oops";
}
The ?? Operator
The final aspect of nullable types to be aware of is that they can make use of the C# ?? operator.
This operator allows you to assign a value to a nullable type if the retrieved value is in fact null. For
this example, assume you wish to assign a local nullable integer to 100 if the value returned from
GetIntFromDatabase() is null (of course, this method is programmed to always return null, but I
am sure you get the general idea):
static void Main(string[] args)
{
Console.WriteLine("***** Fun with Nullable Data *****\n");
DatabaseReader dr = new DatabaseReader();
…
// If the value from GetIntFromDatabase() is null,
138 CHAPTER 4 n CORE C# PROGRAMMING CONSTRUCTS, PART II
// assign local variable to 100.
int? myData = dr.GetIntFromDatabase() ?? 100;
Console.WriteLine("Value of myData: {0}", myData.Value);
Console.ReadLine();
}
Defining Static Classes
Since the release of .NET 2.0, the C# language expanded the scope of the static keyword by introducing
static classes. When a class has been defined as static, it is not creatable using the new
keyword, and it can contain only members or fields marked with the static keyword
Understanding Read-Only Fields
Closely related to constant data is the notion of read-only field data (which should not be confused
with a read-only property). Like a constant, a read-only field cannot be changed after the initial
assignment. However, unlike a constant, the value assigned to a read-only field can be determined
at runtime, and therefore can legally be assigned within the scope of a constructor (but nowhere
else).
The sealed Keyword
C# supplies another keyword, sealed, that prevents inheritance from occurring. When you mark a
class as sealed, the compiler will not allow you to derive from this type. For example, assume you
have decided that it makes no sense to further extend the MiniVan class:
// This class cannot be extended!
sealed class MiniVan : Car
{
}
Sealing Virtual Members
sometimes you may not wish to seal an entire class, but simply want to prevent
derived types from overriding particular virtual methods. For example, assume we do not want
part-time salespeople to obtain customized bonuses. To prevent the PTSalesPerson class from overriding
the virtual GiveBonus() method, we could effectively seal this method in the SalesPerson
class as follows:
// SalesPerson has sealed the GiveBonus() method!
class SalesPerson : Employee
{
…
public override sealed void GiveBonus(float amount)
{
…
}
}
Here, SalesPerson has indeed overridden the virtual GiveBonus() method defined in the
Employee class; however, it has explicitly marked it as sealed. Thus, if we attempted to override this
method in the PTSalesPerson class:
202 CHAPTER 6 n UNDERSTANDING INHERITANCE AND POLYMORPHISM
sealed class PTSalesPerson : SalesPerson
{
public PTSalesPerson(string fullName, int age, int empID,
float currPay, string ssn, int numbOfSales)
:base (fullName, age, empID, currPay, ssn, numbOfSales)
{
}
// No bonus for you! Error!
public override void GiveBonus(float amount)
{
// Rats. Can’t change this method any further.
}
}
we receive compile-time errors.
Obtaining Interface References: The as Keyword
The second way you can determine whether a given type supports an interface is to make use of the
as keyword, which was first introduced in Chapter 6. If the object can be treated as the specified
interface, you are returned a reference to the interface in question. If not, you receive a null reference.
Obtaining Interface References: The is Keyword
The unsafe Keyword
When you wish to work with pointers in C#, you must specifically declare a block of “unsafe code”
using the unsafe keyword (any code that is not marked with the unsafe keyword is considered “safe”
automatically). For example, the following Program class declares a scope of unsafe code within the
safe Main() method:
class Program
{
static void Main(string[] args)
{
unsafe
{
// Work with pointer types here!
}
// Can’t work with pointers here!
}
}

1 thought on “c#学习笔记”