[C#]C# Basics (1)

1. System.Environment and System.Console

public class Program
{
    private static void Main()
    {
        Console.ForegroundColor = ConsoleColor.DarkGreen;

        string[] aArgs = Environment.GetCommandLineArgs();
        foreach (string aArg in aArgs)
        {
            Console.WriteLine("Command Line Args : {0}", aArg);
        }

        Console.WriteLine("Current OS: {0}", Environment.OSVersion);

        Console.WriteLine("Current Directory: {0}", Environment.CurrentDirectory);

        string[] aDrives = Environment.GetLogicalDrives();
        foreach (string aDrive in aDrives)
        {
            Console.WriteLine("Drive {0}", aDrive);
        }

        Console.WriteLine("Executing version of .NET: {0} ", Environment.Version);
    }
}

2. String Formatting Flags

3. Type Visibility

Types (classes, interfaces, structures, enumerations, and delegates) can also take accessibility modifiers,
but are limited to public or internal. (Nested type can be private).

4. Const Fields VS Read-Only Fields VS Static Read-Only Fields

Const Fields:

It is important to understand that the value assigned to a constant variable must be known at compile
time, and therefore a constant member cannot be assigned to an object reference (whose value is
computed at runtime)

internal class ConstData
{
    // The value assigned to a const must be known at compile time.
    public const string BEST_NBA_TEAM = "Timberwolves";
    public const double SIMPLE_PI = 3.14;
    public const bool TRUTH = true;
    public const bool FALSITY = !TRUTH;
}

IL Sample:

 

.field public static literal string BEST_NBA_TEAM = string('Timberwolves')

You can see the value is hard-coded directly into the assembly! And constant fields are implicitly static!

Read-Only Fields

As mentioned earlier, the value assigned to a constant must be known at compile time. However, what
if you wish to create an unchangeable field whose initial value is not known until runtime? Then read-only fields in the choice.

Unlike const however, read-only fields are not implicitly static; therefore if you wish to expose such data at class level, the static keyword must be included.

class Tire
{
    public readonly static Tire GoodStone = new Tire(90);
    public readonly static Tire FireYear = new Tire(100);
    public int manufactureID;
    public Tire() {}
    public Tire(int ID)
    { manufactureID = ID; }
}

Read-only fields have another distinction from constant data: their value may be assigned within the scope of a constructor. This can be very useful if the value to assign to a read-only field must be read from an external source (such as a text file or database).

Static Read-Only Fields

Unlike constant data, read-only fields are not implicitly static. If you wish to allow object users to obtain the value of a read-only field from the class level, simply make use of the static keyword:

5. Static Constructor

  

Static constructor is mainly used to initialize the static field.

虽然static field的值可以在声明的时候进行赋值，但是有时候可能该值不是简单的字面值或者一个expression就可以搞定，像new XXX()之类，如果需要进行好几个statement操作才可以得到该static field的初始值(比如说从数据库中取值），这个时候需要把这些操作放到一个方法里面才行。如果是放到instance constructor里面，这样每实例化一个对象的时候，这个static field就会被重新赋值一下，就失去了static field的真正意义，因此这个时候需要把这些操作放到static constructor中。

Here are a few points of interest regarding static constructors:
• A given class (or structure) may define only a single static constructor.
• A static constructor executes exactly one time, regardless of how many objects of the type are created.
• A static constructor does not take an access modifier and cannot take any parameters.
• The runtime invokes the static constructor when it creates an instance of the class or before accessing the first static member invoked by the caller.
• The static constructor executes before any instance-level constructors.

6. Static Classes

  

C# 2005 （c# 2.0)  has widened 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 static members or fields (if this is not the case, you receive compiler errors).

At first glance, this might seem like a very useless feature, given that a class that cannot be created does not appear all that helpful. However, if you create a class that contains nothing but static members and/or constant data, the class has no need to be allocated in the first place.

Prior to C# 2005, the only way to prevent an object user from creating such a type was to either redefine the default constructor as private or mark the class as an abstract type using the C# abstract keyword.

7. The Switch Statement

One nice feature of the C# switch statement is that you can evaluate string data in addition to numeric data.

8. System.Object

// The topmost class in the .NET universe: System.Object
namespace System
{
    public class Object
    {
        public Object();
        public virtual Boolean Equals(Object obj);
        public virtual Int32 GetHashCode();
        public Type GetType();
        public virtual String ToString();
        protected virtual void Finalize();
        protected Object MemberwiseClone();
        public static bool Equals(object objA, object objB);
        public static bool ReferenceEquals(object objA, object objB);
    }
}

static : Equals / ReferenceEquals

virtual: Equals (reference comparison by default)/ GetHashCode

protected: MemberwiseClone / Finalize

Override GetHashCode()

By and large, overriding this method is only useful if you intend to store a custom type within
a hash-based collection such as System.Collections.Hashtable. Under the hood, the Hashtable type
calls the Equals() and GetHashCode() members of the contained types to determine the correct object
to return to the caller.

There are many algorithms that can be used to create a hash code—some fancy, others not so fancy. As mentioned, an object’s hash value will be based on its state data. As luck would have it, the System.String class has a very solid implementation of GetHashCode() that is based on the string’s
character data.

9. System.String

You should be aware that although string is a reference type, the equality operators (== and !=) are defined to compare the value with the string objects, not the memory to which they refer.

10. Nullable Type

[Serializable, StructLayout(LayoutKind.Sequential), TypeDependency("System.Collections.Generic.NullableComparer`1"), TypeDependency("System.Collections.Generic.NullableEqualityComparer`1")]
public struct Nullable<T> where T: struct
{
    private bool hasValue;
    internal T value;
    public Nullable(T value);
    public bool HasValue { get; }
    public T Value { get; }
    public T GetValueOrDefault();
    public T GetValueOrDefault(T defaultValue);
    public override bool Equals(object other);
    public override int GetHashCode();
    public override string ToString();
    public static implicit operator T?(T value);
    public static explicit operator T(T? value);
}

[Serializable, StructLayout(LayoutKind.Sequential), TypeDependency("System.Collections.Generic.NullableComparer`1"), TypeDependency("System.Collections.Generic.NullableEqualityComparer`1")]
public struct Nullable<T> where T: struct
{
    private bool hasValue;
    internal T value;
    public Nullable(T value)
    {
        this.value = value;
        this.hasValue = true;
    }

    public bool HasValue
    {
        get
        {
            return this.hasValue;
        }
    }
    public T Value
    {
        get
        {
            if (!this.HasValue)
            {
                ThrowHelper.ThrowInvalidOperationException(ExceptionResource.InvalidOperation_NoValue);
            }
            return this.value;
        }
    }
    public T GetValueOrDefault()
    {
        return this.value;
    }

    public T GetValueOrDefault(T defaultValue)
    {
        if (!this.HasValue)
        {
            return defaultValue;
        }
        return this.value;
    }

    public override bool Equals(object other)
    {
        if (!this.HasValue)
        {
            return (other == null);
        }
        if (other == null)
        {
            return false;
        }
        return this.value.Equals(other);
    }

    public override int GetHashCode()
    {
        if (!this.HasValue)
        {
            return 0;
        }
        return this.value.GetHashCode();
    }

    public override string ToString()
    {
        if (!this.HasValue)
        {
            return "";
        }
        return this.value.ToString();
    }

    public static implicit operator T?(T value)
    {
        return new T?(value);
    }

    public static explicit operator T(T? value)
    {
        return value.Value;
    }
}