在C#中创建类型

简介: 重载构造函数: using System;public class Wine{ public decimal Price; public int Year; public Wine (decimal price) { Pric...

重载构造函数:

using System;

public class Wine
{
  public decimal Price;
  public int Year;
  public Wine (decimal price) { Price = price; }
  public Wine (decimal price, int year) : this (price) { Year = year; }
}

对象初始化:

public class Bunny
{
  public string Name;
  public bool LikesCarrots;
  public bool LikesHumans;

  public Bunny () {}
  public Bunny (string n) { Name = n; }
}
Bunny b1 = new Bunny { Name="Bo", LikesCarrots=true, LikesHumans=false };
Bunny b2 = new Bunny ("Bo")     { LikesCarrots=true, LikesHumans=false };

this引用:

public class Panda
{
  public Panda Mate;

  public void Marry (Panda partner)
  {
    Mate = partner;
    partner.Mate = this;
  }
}
public class Test
{
  string name;
  public Test (string name) { this.name = name; }
}

属性:

public class Stock
{
  decimal currentPrice;           // The private "backing" field

  public decimal CurrentPrice     // The public property
  {
     get { return currentPrice; } set { currentPrice = value; }
  }
}

只读和已计算属性:

public class Stock
{
  string  symbol;
  decimal purchasePrice, currentPrice;
  long    sharesOwned;

  public Stock (string symbol, decimal purchasePrice, long sharesOwned)
  {
    this.symbol = symbol;
    this.purchasePrice = currentPrice = purchasePrice;
    this.sharesOwned = sharesOwned;
  }

  public decimal CurrentPrice  { get { return currentPrice;             }
                                 set { currentPrice = value;            } }
  public string Symbol         { get { return symbol;                   } }
  public decimal PurchasePrice { get { return purchasePrice;            } }
  public long    SharesOwned   { get { return sharesOwned;              } }
  public decimal Worth         { get { return CurrentPrice*SharesOwned; } }
}

class Test
{
  static void Main()
  {
    Stock msft = new Stock ("MSFT", 20, 1000);
    Console.WriteLine (msft.Worth);                // 20000
    msft.CurrentPrice = 30;
    Console.WriteLine (msft.Worth);                // 30000
  }
}

自动属性:

public class Stock
{
  // ...
  public decimal CurrentPrice { get; set; }
}

get 和 set 访问:

public class Foo
{
  private decimal x;
  public decimal X
  {
    get          {return x;} 
    internal set {x = value;}
  }
}

实现索引:

public class Portfolio
{
  Stock[] stocks;
  public Portfolio (int numberOfStocks)
  {
    stocks = new Stock [numberOfStocks];
  }

  public int NumberOfStocks { get { return stocks.Length; } }

  public Stock this [int index]      // indexer
  { 
    get { return stocks [index];  }
    set { stocks [index] = value; }
  }
}

class Test
{
  static void Main()
  {
    Portfolio portfolio = new Portfolio(3);
    portfolio [0] = new Stock ("MSFT", 20, 1000);
    portfolio [1] = new Stock ("GOOG", 300, 100);
    portfolio [2] = new Stock ("EBAY", 33, 77);

    for (int i = 0; i < portfolio.NumberOfStocks; i++)
      Console.WriteLine (portfolio[i].Symbol);
  }
}

多索引:

public class Portfolio
{
  ...
  public Stock this[string symbol]
  {
    get
    {
      foreach (Stock s in stocks)
        if (s.Symbol == symbol)
          return s;
      return null;
    }
  }
}

静态构造函数:

class Test
{
  static Test()
  {
    Console.WriteLine ("Type Initialized");
  }
}

Partial方法:

// PaymentFormGen.cs — auto-generated
partial class PaymentForm
{
  // ...
  partial void ValidatePayment(decimal amount);
}
// PaymentForm.cs — hand-authored
partial class PaymentForm
{
  // ...
  // partial void ValidatePayment(decimal amount)
  {
    if (amount > 100)
    {
      // ...
    }
  }
}

继承:

public class Asset
{
  public string  Name;
  public decimal PurchasePrice, CurrentPrice;
}
public class Stock : Asset   // inherits from Asset
{
  public long SharesOwned;
}

public class House : Asset   // inherits from Asset
{
  public decimal Mortgage;
}

class Test
{
  static void Main()
  {
    Stock msft = new Stock()
    { Name="MSFT", PurchasePrice=20, CurrentPrice=30, SharesOwned=1000 };

    House mansion = new House
    { Name="McMansion", PurchasePrice=300000, CurrentPrice=200000,
      Mortgage=250000 };

    Console.WriteLine (msft.Name);           // MSFT
    Console.WriteLine (mansion.Name);        // McMansion

    Console.WriteLine (msft.SharesOwned);    // 1000
    Console.WriteLine (mansion.Mortgage);    // 250000
  }
}

多态:

class Test
{
  static void Main()
  {
    Stock msft    = new Stock ... ;
    House mansion = new House ... ;
    Display (msft);
    Display (mansion);
  }

  public static void Display (Asset asset)
  {
    System.Console.WriteLine (asset.Name);
  }
}
static void Main() { Display (new Asset()); }    // Compile-time error

public static void Display (House house)         // Will not accept Asset
{
  System.Console.WriteLine (house.Mortgage);
}

向下转换:

Stock msft = new Stock();
Asset a = msft;                      // upcast
Stock s = (Stock)a;                  // downcast
Console.WriteLine (s.SharesOwned);   // <No error>
Console.WriteLine (s == a);          // true
Console.WriteLine (s == msft);       // true

虚拟函数成员:

public class Asset
{
  ...
  public virtual decimal Liability { get { return 0; } }
}
public class Stock : Asset { ... }

public class House : Asset
{
  ...
  public override decimal Liability { get { return Mortgage; } }
}
House mansion = new House
 { Name="McMansion", PurchasePrice=300000, CurrentPrice=200000,
   Mortgage=250000 };

Asset a = mansion;
decimal d2 = mansion.Liability;      // 250000

抽象类和抽象成员:

public abstract class Asset
{
  ...
  public abstract decimal NetValue { get; }   // Note empty implementation
}

public class Stock : Asset
{
  ...                                     // Override an abstract method
  public override decimal NetValue        // just like a virtual method.
  {
    get { return CurrentPrice * SharesOwned; }
  }
}

public class House : Asset     // Every non abstract subtype must
{                              // define NetValue.
  ...
  public override decimal NetValue
  {
    get { return CurrentPrice - Mortgage; }
  }
}

new 和 virtual

public class BaseClass
{
  public virtual void Foo()  { Console.WriteLine ("BaseClass.Foo"); }
}

public class Overrider : BaseClass
{
  public override void Foo() { Console.WriteLine ("Overrider.Foo"); }
}

public class Hider : BaseClass
{
  public new void Foo()      { Console.WriteLine ("Hider.Foo"); }
}
Overrider o = new Overrider();
BaseClass b1 = o;
o.Foo();                           // Overrider.Foo
b1.Foo();                          // Overrider.Foo

Hider h = new Hider();
BaseClass b2 = h;
h.Foo();                           // Hider.Foo
b2.Foo();                          // BaseClass.Foo

GetType() 和 typeof

using System;

public class Point {public int X, Y;}

class Test
{
  static void Main()
  {
    Point p = new Point();
    Console.WriteLine (p.GetType().Name);             // Point
    Console.WriteLine (typeof (Point).Name);          // Point
    Console.WriteLine (p.GetType() == typeof(Point)); // True
    Console.WriteLine (p.X.GetType().Name);           // Int32
    Console.WriteLine (p.Y.GetType().FullName);       // System.Int32
  }
}

显式接口实现:

interface I1 { void Foo(); }
interface I2 { int Foo(); }

public class Widget : I1, I2
{
  public void Foo ()
  {
    Console.WriteLine ("Widget's implementation of I1.Foo");
  }

  int I2.Foo ()
  {
    Console.WriteLine ("Widget's implementation of I2.Foo");
    return 42;
  }
}
Widget w = new Widget();
w.Foo();                      // Widget's implementation of I1.Foo
((I1)w).Foo();                // Widget's implementation of I1.Foo 
((I2)w).Foo();                // Widget's implementation of I2.Foo

虚拟地实现接口成员:

public interface IUndoable { void Undo(); }

public class TextBox : IUndoable
{
  public virtual void Undo()
  {
     Console.WriteLine ("TextBox.Undo");
  }
}

public class RichTextBox : TextBox
{
  public override void Undo()
  {
    Console.WriteLine ("RichTextBox.Undo");
  }
}
RichTextBox r = new RichTextBox();
r.Undo();                          // RichTextBox.Undo
((IUndoable)r).Undo();             // RichTextBox.Undo
((TextBox)r).Undo();               // RichTextBox.Undo

在子类中重新实现一个接口:

public interface IUndoable { void Undo(); }

public class TextBox : IUndoable
{
  void IUndoable.Undo() { Console.WriteLine ("TextBox.Undo"); }
}

public class RichTextBox : TextBox, IUndoable
{
  public new void Undo() { Console.WriteLine ("RichTextBox.Undo"); }
}
RichTextBox r = new RichTextBox();
r.Undo();                 // RichTextBox.Undo      Case 1
((IUndoable)r).Undo();    // RichTextBox.Undo      Case 2
public class TextBox : IUndoable
{
  public void Undo() { Console.WriteLine ("TextBox.Undo"); }
}
RichTextBox r = new RichTextBox();
r.Undo();                 // RichTextBox.Undo      Case 1
((IUndoable)r).Undo();    // RichTextBox.Undo      Case 2
((TextBox)r).Undo();      // TextBox.Undo          Case 3

替代接口重新实现:

public class TextBox : IUndoable
{
  void IUndoable.Undo()         { Undo(); }   // Calls method below
  protected virtual void Undo() { Console.WriteLine ("TextBox.Undo"); }
}

public class RichTextBox : TextBox
{
  protected override void Undo() { Console.WriteLine ("RichTextBox.Undo"); }
}

Flags enums枚举:

[Flags]
public enum BorderSides { Left=1, Right=2, Top=4, Bottom=8 }
BorderSides leftRight = BorderSides.Left | BorderSides.Right;

if ((leftRight & BorderSides.Left) != 0)
   System.Console.WriteLine ("Includes Left");   // Includes Left

string formatted = leftRight.ToString();   // "Left, Right"

BorderSides s = BorderSides.Left;
s |= BorderSides.Right;
Console.WriteLine (s == leftRight);   // True

s ^= BorderSides.Right;               // Toggles BorderSides.Right
Console.WriteLine (s);                // Left  

Enum枚举类型安全问题:

static bool IsFlagDefined (Enum e)
{
  decimal d;
  return ! decimal.TryParse(e.ToString(), out d);
}

[Flags]
public enum BorderSides { Left=1, Right=2, Top=4, Bottom=8 }

static void Main()
{
  for (int i = 0; i <= 16; i++)
  {
    BorderSides side = (BorderSides)i;
    Console.WriteLine (IsFlagDefined (side) + " " + side);
  }
}

泛型:

public class Stack<T>
{
  int position;
  T[] data = new T[100];
  public void Push (T obj)        { data[position++] = obj;  }
  public T Pop ()                 { return data[--position]; }
}
Stack<int> stack = new Stack<int>(); 
stack.Push(5);
stack.Push(10);
int x = stack.Pop();

泛方法:

static void Swap<T> (ref T a, ref T b)
{
  T temp = b;
  a = b;
  b = temp;
}

默认泛值:

static void Zap<T> (T[] array)
{
  for (int i = 0; i < array.Length; i++)
    array[i] = default(T);
}

约束:

static T Max <T> (T a, T b) where T : IComparable<T>
{
  return a.CompareTo (b) > 0 ? a : b;
}
static void Initialize<T> (T[] array) where T : new()
{
  for (int i = 0; i < array.Length; i++)
    array[i] = new T(); 
}
class Stack<T>
{
  Stack<U> FilteredStack<U>() where U : T {...}
}

泛型和协方差:

class Animal {}
class Bear : Animal {}
public class ZooCleaner
{
  public static void Wash<T> (Stack<T> animals) where T : Animal {}
}
Stack<Bear> bears = new Stack<Bear>();
ZooCleaner.Wash (bears);

自引用泛型声明:

interface IEquatable<T> { bool Equals (T obj); }

public class Balloon : IEquatable<Balloon>
{
  string color;
  int cc;

  public bool Equals (Balloon b)
  {
    if (b == null) return false;
    return b.color == color && b.cc == cc;
  }
}

泛型类型中的静态数据唯一:

public class Bob<T> { public static int Count; }

class Test
{
  static void Main()
  {
    Console.WriteLine (++Bob<int>.Count);     // 1
    Console.WriteLine (++Bob<int>.Count);     // 2
    Console.WriteLine (++Bob<string>.Count);  // 1
    Console.WriteLine (++Bob<object>.Count);  // 1
  }
}

对象初始化:

List<int> list = new List<int> {1, 2, 3};
目录
相关文章
|
3月前
|
存储 安全 编译器
C# 11.0中的泛型属性:类型安全的新篇章
【1月更文挑战第23天】C# 11.0引入了泛型属性的概念,这一新特性为开发者提供了更高级别的类型安全性和灵活性。本文将详细探讨C# 11.0中泛型属性的工作原理、使用场景以及它们对现有编程模式的改进。通过深入了解泛型属性,开发者将能够编写更加健壮、可维护的代码,并充分利用C#语言的最新发展。
|
7月前
|
编译器 C#
C#之十七 局部类型
C#之十七 局部类型
17 0
|
1月前
|
存储 C# 开发者
C#变量类型
C#变量类型
19 0
|
3月前
|
开发框架 .NET 编译器
C# 9.0中的目标类型新表达式:类型推断的又一进步
【1月更文挑战第16天】C# 9.0引入了目标类型新表达式,这是类型推断功能的一个重要扩展。通过目标类型新表达式,开发者在创建对象时可以省略类型名称,编译器会根据上下文自动推断所需类型。这一特性不仅简化了代码编写,还提高了代码的可读性和维护性。本文将详细介绍目标类型新表达式的语法、使用场景及其对C#编程的影响。
|
3月前
|
存储 C# 容器
掌握 C# 变量:在代码中声明、初始化和使用不同类型的综合指南
变量是用于存储数据值的容器。 在 C# 中,有不同类型的变量(用不同的关键字定义),例如: int - 存储整数(没有小数点的整数),如 123 或 -123 double - 存储浮点数,有小数点,如 19.99 或 -19.99 char - 存储单个字符,如 'a' 或 'B'。Char 值用单引号括起来 string - 存储文本,如 "Hello World"。String 值用双引号括起来 bool - 存储具有两个状态的值:true 或 false
37 2
|
3月前
|
存储 安全 算法
C# 泛型:类型参数化的强大工具
【1月更文挑战第7天】本文将深入探讨C#语言中的泛型编程,包括泛型的定义、用途、优势以及实际应用。通过类型参数化,泛型允许开发者编写更加灵活且可重用的代码,同时提高程序的类型安全性和性能。本文将通过示例代码和详细解释,帮助读者更好地理解泛型在C#中的重要性和实用性。
|
4月前
|
存储 Java C#
【从Java转C#】第七章:运算符和类型强制转换
【从Java转C#】第七章:运算符和类型强制转换
|
4月前
|
Java 编译器 C#
【从Java转C#】第三章:对象和类型
【从Java转C#】第三章:对象和类型
|
7月前
|
C#
C#中的可空类型修饰符
什么是C#中的可空类型修饰符?如何使用呢?
71 0
|
9月前
|
C#
C#中 Int32.TryParse() ConVert.ToInt32() Int32.Parse () 的区别 将字符串类型转换为数字类型
C#中 Int32.TryParse() ConVert.ToInt32() Int32.Parse () 的区别 将字符串类型转换为数字类型
35 0