重载构造函数:

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};

在C#中创建类型的更多相关文章

  1. C++中结构体与类的区别(结构不能被继承,默认是public,在堆栈中创建,是值类型,而类是引用类型)good

    结构是一种用关键字struct声明的自定义数据类型.与类相似,也可以包含构造函数,常数,字段,方法,属性,索引器,运算符和嵌套类型等,不过,结构是值类型. 1.结构的构造函数和类的构造函数不同. a. ...

  2. 关于Emit中动态类型TypeBuilder创建类标记的一点思考

      利用TypeBuilder是可以动态创建一个类型,现在有个需求,动态生成一个dll,创建类型EmployeeEx,需要继承原dll里面的Employee类,并包含Employee类上的所有类标记. ...

  3. 【转载】 Java中String类型的两种创建方式

    本文转载自 https://www.cnblogs.com/fguozhu/articles/2661055.html Java中String是一个特殊的包装类数据有两种创建形式: String s ...

  4. Java归去来第4集:java实战之Eclipse中创建Maven类型的SSM项目

    一.前言 如果还不了解剧情,请返回第3集的剧情          Java归去来第3集:Eclipse中给动态模块升级 二.在Eclipse中创建Maven类型的SSM项目 2.1:SSM简介 SSM ...

  5. 在 QML 中创建 C++ 导入类型的实例

    在 QML 中创建 C++ 导入类型的实例 文件列表: Project1.pro QT += quick CONFIG += c++ CONFIG += declarative_debug CONFI ...

  6. 受检查异常要求try catch,new对象时,就会在堆中创建内存空间,创建的空间包括各个成员变量类型所占用的内存空间

    ,new对象时,就会在堆中创建内存空间,创建的空间包括各个成员变量类型所占用的内存空间

  7. 图像处理中创建CDib类时无法选择基类类型时怎么办

    图像处理中创建CDib类时无法选择基类类型时怎么办? 类的类型选择Generic Class 在下面的篮筐里输入CObject就行了

  8. In-Memory:在内存中创建临时表和表变量

    在Disk-Base数据库中,由于临时表和表变量的数据存储在tempdb中,如果系统频繁地创建和更新临时表和表变量,大量的IO操作集中在tempdb中,tempdb很可能成为系统性能的瓶颈.在SQL ...

  9. 详解Linux交互式shell脚本中创建对话框实例教程_linux服务器

    本教程我们通过实现来讲讲Linux交互式shell脚本中创建各种各样对话框,对话框在Linux中可以友好的提示操作者,感兴趣的朋友可以参考学习一下. 当你在终端环境下安装新的软件时,你可以经常看到信息 ...

随机推荐

  1. Solution for latex error:”Unknown graphics extension: .eps“ or "Can not find XXX"

    Sample code: \begin{figure*} \centering % Requires \usepackage{graphicx} \includegraphics[width=7in] ...

  2. POJ 3764 (异或+字典树)

    早就听过用字典树求异或最大值,然而没做过.发现一碰到异或的题就GG,而且因为以前做过的一道类似的题(事实上并不类似)限制了思路,蠢啊= =. 题意:一棵带权的树,求任意两点间路径异或的最大值. 题解: ...

  3. A Tour of Go Buffered Channels

    Channels can be buffered. Provide the buffer length as the second argument to make to initialize a b ...

  4. Qt 固定窗口【worldsing 笔记】

    w.setWindowFlags(Qt::WindowMinimizeButtonHint); //禁止最大化按钮 w.setFixedSize(1024,587);//固定窗口大小

  5. 编写Qt Designer自定义控件(二)——编写自定义控件界面

    接上文:编写Qt Designer自定义控件(一)——如何创建并使用Qt自定义控件 既然是控件,就应该有界面,默认生成的控件类只是一个继承了QWidget的类,如下: #ifndef LOGLATED ...

  6. Unity3D4.x之AssetBundle学习笔记

    关于AssetBundle AssetBundle可用来将多个资源打包为一个文件,实现动态下载和更新.需要注意的是Unity3D5.x以后对打包方式进行了升级,不用再在依赖关系上伤透脑筋,但是和4.x ...

  7. 常用 Unicode 符号列表

    Unicode 中包含了各种符号,我们可以作为图标来使用.这里整理一下常用的一些符号. 一.拉丁字母补全(Latin-1 Supplement):U+0080 至 U+00FF Unicode 编号 ...

  8. ThinkPHP CURD方法盘点:where方法

    今天来给大家讲下查询最常用但也是最复杂的where方法,where方法也属于模型类的连贯操作方法之一,主要用于查询和操作条件的设置.where方法的用法是ThinkPHP查询语言的精髓,也是Think ...

  9. SpringMVC+Spring3+hibernate4 开发环境搭建以及一个开发实例教程

    刚刚接触了SpringMVC这个框架,因此有必要把它拿过来同hibernate.Spring框架进行集成和开发一个实例,在真正企业从头开发的项目中往往一个稳定的开发环境至关重要,开发一个项目选择什么样 ...

  10. STL之Map的运用

    Map是c++的一个标准容器,她提供了非常好一对一的关系,在一些程序中建立一个map能够起到事半功倍的效果,总结了一些map基本简单有用的操作! 1. map最主要的构造函数:    map<s ...