สิ่งนี้อยู่ในใจของฉันหลังจากฉันเรียนรู้จากคำถามนี้ :

where T : struct

พวกเราผู้พัฒนา C # ทุกคนรู้พื้นฐานของ C # ฉันหมายถึงการประกาศเงื่อนไขเงื่อนไขลูปตัวดำเนินการ ฯลฯ

พวกเราบางคนเข้าใจสิ่งต่าง ๆ เช่นGenerics , ประเภทนิรนาม , lambdas , LINQ , ...

แต่คุณสมบัติหรือลูกเล่นที่ซ่อนอยู่ของ C # ที่แม้แต่แฟน C #, ผู้ติดยา, ผู้เชี่ยวชาญแทบจะไม่รู้คืออะไร?

นี่คือคุณสมบัติที่เปิดเผยแล้ว:

คำสำคัญ

• yieldโดยMichael Stum
• varโดยMichael Stum
• using()คำสั่งโดยkokos
• readonlyโดยkokos
• asโดยMike Stone
• as/ isโดยEd Swangren
• as/ is(ปรับปรุง) โดยRocketpants
• defaultโดยDeathofrats
• global::โดยpzycoman
• using()บล็อกโดยAlexCuse
• volatileโดยJakub Šturc
• extern aliasโดยJakub Šturc

คุณลักษณะ

• DefaultValueAttributeโดยMichael Stum
• ObsoleteAttributeโดยDannySmurf
• DebuggerDisplayAttributeโดยStu
• DebuggerBrowsableและDebuggerStepThroughโดยbdukes
• ThreadStaticAttributeโดยmarxidad
• FlagsAttributeโดยMartin Clarke
• ConditionalAttributeโดยAndrewBurns

วากยสัมพันธ์

• ??(รวมตัวกันเป็นโมฆะ ) โอเปอเรเตอร์โดยkokos
• การตีธงหมายเลขโดยNick Berardi
• where T:newโดยLars Mæhlum
• ข้อมูลทั่วไปโดยนัยโดยKeith
• lambdas หนึ่งพารามิเตอร์โดยKeith
• คุณสมบัติอัตโนมัติโดยKeith
• นามแฝง Namespace โดยKeith
• ตัวอักษรของคำต่อท้ายสตริงด้วย @ โดยPatrick
• enumค่าโดยlfoust
• @variablenames โดยmarxidad
• eventผู้ประกอบการโดยmarxidad
• จัดรูปแบบวงเล็บสตริงโดยPortman
• ตัวดัดแปลงการเข้าถึงการเข้าถึงคุณสมบัติโดยxanadont
• ผู้ประกอบการ?:ตามเงื่อนไข (ที่ประกอบไปด้วย) ( ) โดยJasonS
• checkedและuncheckedผู้ประกอบการโดยBinoj Antony
• implicit and explicitผู้ประกอบการโดยFlory

คุณสมบัติทางภาษา

• ประเภทที่ทำให้เป็นโมฆะโดยแบรดบาร์เกอร์
• ประเภทที่ไม่ระบุตัวตนโดยKeith
• __makeref __reftype __refvalueโดยยูดาห์ Himango
• วัตถุ initializers โดยlomaxx
• จัดรูปแบบสตริงโดยDavid ในดาโคตา
• วิธีการขยายโดยmarxidad
• partialวิธีการโดยJon Erickson
• คำสั่งของผู้ประมวลผลล่วงหน้าโดยJohn Asbeck
• DEBUGคำสั่งประมวลผลล่วงหน้าโดยRobert Durgin
• ผู้ประกอบการมากไปโดยSefBkn
• พิมพ์ inferrence โดยชาคริต
• ตัวดำเนินการบูลีนนำไปสู่อีกระดับโดยRob Gough
• ผ่านตัวแปรประเภทค่าเป็นส่วนต่อประสานที่ไม่มีมวยโดยRoman Boiko
• โปรแกรมกำหนดประเภทตัวแปรที่ประกาศโดยRoman Boiko
• ตัวสร้างแบบคงที่โดยChris
• การทำแผนที่ ORM แบบย่อที่ง่ายขึ้นโดยใช้ LINQ โดยroosteronacid
• __arglistโดยZac Bowling

คุณสมบัติของ Visual Studio

• เลือกบล็อคข้อความในโปรแกรมแก้ไขโดยHimadri
• ตัวอย่างโดยDannySmurf

กรอบ

• TransactionScopeโดยKiwiBastard
• DependantTransactionโดยKiwiBastard
• Nullable<T>โดยIainMH
• MutexโดยDiago
• System.IO.Pathโดยageektrapped
• WeakReferenceโดยJuan Manuel

วิธีการและคุณสมบัติ

• String.IsNullOrEmpty()วิธีการโดยKiwiBastard
• List.ForEach()วิธีการโดยKiwiBastard
• BeginInvoke(), EndInvoke()วิธีการโดยจะคณบดี
• Nullable<T>.HasValueและNullable<T>.ValueคุณสมบัติโดยRismo
• GetValueOrDefaultวิธีการโดยJohn Sheehan

เคล็ดลับ & เทคนิค

• วิธีการที่ดีสำหรับตัวจัดการเหตุการณ์โดยAndreas HR Nilsson
• การเปรียบเทียบตัวพิมพ์ใหญ่โดยJohn
• เข้าถึงประเภทที่ไม่ระบุตัวตนโดยไม่มีการสะท้อนกลับโดยdp
• วิธีที่รวดเร็วในการยกตัวอย่างคุณสมบัติการรวบรวมโดยWill
• ฟังก์ชั่นอินไลน์แบบไม่ระบุชื่อเหมือน JavaScript โดยroosteronacid

อื่น ๆ

• netmodules โดยkokos
• LINQBridgeโดยDuncan Smart
• ส่วนขยายแบบขนานโดยJoel Coehoorn

นี่ไม่ใช่ C # ต่อ se แต่ฉันไม่ได้เห็นใครที่ใช้จริงๆSystem.IO.Path.Combine()เท่าที่ควร อันที่จริงคลาส Path ทั้งหมดนั้นมีประโยชน์จริง ๆ แต่ไม่มีใครใช้เลย!

ฉันยินดีที่จะเดิมพันว่าแอปที่ใช้งานจริงทุกตัวมีรหัสต่อไปนี้ถึงแม้ว่ามันจะไม่ควร:

string path = dir + "\\" + fileName;

lambdas และการอนุมานชนิดมีการประเมินค่าต่ำเกินไป แลมบ์ดาสามารถมีหลายข้อความและพวกเขาเป็นสองเท่าในฐานะตัวแทนวัตถุที่เข้ากันได้โดยอัตโนมัติ (ตรวจสอบให้แน่ใจว่าลายเซ็นตรงกัน) ใน:

Console.CancelKeyPress +=
    (sender, e) => {
        Console.WriteLine("CTRL+C detected!\n");
        e.Cancel = true;
    };

โปรดทราบว่าฉันไม่ได้มีnew CancellationEventHandlerหรือฉันต้องระบุประเภทsenderและeพวกเขาจะอนุมานได้จากเหตุการณ์ นี่คือเหตุผลว่าทำไมการเขียนทั้งหมดจึงมีความยุ่งยากน้อยกว่าdelegate (blah blah)ซึ่งคุณต้องระบุประเภทของพารามิเตอร์ด้วย

แลมบัลดัสไม่จำเป็นต้องส่งคืนสิ่งใดและการอนุมานประเภทมีประสิทธิภาพอย่างยิ่งในบริบทเช่นนี้

และ BTW คุณสามารถส่งคืนแลมบ์ดาที่ทำให้แลมบ์ดามีความสามารถในการตั้งโปรแกรมได้ ตัวอย่างเช่นนี่คือแลมบ์ดาที่สร้างแลมบ์ดาที่จัดการกับเหตุการณ์ Button.Click:

Func<int, int, EventHandler> makeHandler =
    (dx, dy) => (sender, e) => {
        var btn = (Button) sender;
        btn.Top += dy;
        btn.Left += dx;
    };

btnUp.Click += makeHandler(0, -1);
btnDown.Click += makeHandler(0, 1);
btnLeft.Click += makeHandler(-1, 0);
btnRight.Click += makeHandler(1, 0);

หมายเหตุการผูกมัด: (dx, dy) => (sender, e) =>

นี่คือเหตุผลที่ฉันมีความสุขที่ได้เรียนการเขียนโปรแกรมฟังก์ชั่น :-)

นอกเหนือจากพอยน์เตอร์ใน C ฉันคิดว่านี่เป็นสิ่งพื้นฐานอื่น ๆ ที่คุณควรเรียนรู้ :-)

จากRick Strahl :

คุณสามารถโยง ?? โอเปอเรเตอร์เพื่อให้คุณสามารถทำการเปรียบเทียบเป็นโมฆะ

string result = value1 ?? value2 ?? value3 ?? String.Empty;

ชื่อสามัญนามแฝง:

using ASimpleName = Dictionary<string, Dictionary<string, List<string>>>;

จะช่วยให้คุณใช้แทนASimpleNameDictionary<string, Dictionary<string, List<string>>>

ใช้มันเมื่อคุณจะใช้สิ่งที่มีขนาดใหญ่ยาวซับซ้อนเหมือนกันในหลาย ๆ ที่

จากCLR ผ่าน C # :

เมื่อสตริง normalizing ก็ขอแนะนำให้คุณใช้ ToUpperInvariant แทน ToLowerInvariant เพราะไมโครซอฟท์มีการเพิ่มประสิทธิภาพรหัสสำหรับการดำเนินการเปรียบเทียบตัวพิมพ์ใหญ่

ฉันจำครั้งหนึ่งที่ผู้ร่วมงานของฉันเปลี่ยนสตริงเป็นตัวพิมพ์ใหญ่เสมอก่อนที่จะเปรียบเทียบ ฉันสงสัยอยู่เสมอว่าทำไมเขาถึงทำอย่างนั้นเพราะฉันรู้สึกว่า "เป็นธรรมชาติ" มากกว่าที่จะเปลี่ยนเป็นตัวพิมพ์เล็กก่อน หลังจากอ่านหนังสือตอนนี้ฉันรู้ว่าทำไม

เคล็ดลับที่ฉันโปรดปรานคือการใช้ตัวดำเนินการรวมศูนย์และวงเล็บเพื่อสร้างตัวอย่างให้ฉันโดยอัตโนมัติ

private IList<Foo> _foo;

public IList<Foo> ListOfFoo 
    { get { return _foo ?? (_foo = new List<Foo>()); } }

หลีกเลี่ยงการตรวจสอบตัวจัดการเหตุการณ์ null

การเพิ่มผู้รับมอบสิทธิ์ที่ว่างลงในเหตุการณ์เมื่อมีการประกาศระงับความจำเป็นที่จะต้องตรวจสอบเหตุการณ์เพื่อหาค่าว่างก่อนที่จะเรียกมันว่ายอดเยี่ยม ตัวอย่าง:

public delegate void MyClickHandler(object sender, string myValue);
public event MyClickHandler Click = delegate {}; // add empty delegate!

ให้คุณทำสิ่งนี้

public void DoSomething()
{
    Click(this, "foo");
}

แทนที่จะเป็นแบบนี้

public void DoSomething()
{
    // Unnecessary!
    MyClickHandler click = Click;
    if (click != null) // Unnecessary! 
    {
        click(this, "foo");
    }
}

โปรดดูการสนทนาที่เกี่ยวข้องและบล็อกโพสต์นี้โดย Eric Lippert ในหัวข้อนี้ (และข้อเสียที่เป็นไปได้)

ทุกอย่างอื่นรวมทั้ง

1) generics โดยนัย (ทำไมต้องใช้วิธีการเท่านั้นและไม่ได้เรียน)

void GenericMethod<T>( T input ) { ... }

//Infer type, so
GenericMethod<int>(23); //You don't need the <>.
GenericMethod(23);      //Is enough.

2) lambdas ง่าย ๆ ด้วยพารามิเตอร์เดียว:

x => x.ToString() //simplify so many calls

3) ประเภทและผู้เริ่มต้นที่ไม่ระบุชื่อ:

//Duck-typed: works with any .Add method.
var colours = new Dictionary<string, string> {
    { "red", "#ff0000" },
    { "green", "#00ff00" },
    { "blue", "#0000ff" }
};

int[] arrayOfInt = { 1, 2, 3, 4, 5 };

อีกหนึ่ง:

4) คุณสมบัติอัตโนมัติสามารถมีขอบเขตที่แตกต่างกัน:

public int MyId { get; private set; }

ขอบคุณ @pcomcoman สำหรับการเตือนฉัน:

5) นามแฝง Namespace (ไม่ใช่ว่าคุณต้องการความแตกต่างนี้):

using web = System.Web.UI.WebControls;
using win = System.Windows.Forms;

web::Control aWebControl = new web::Control();
win::Control aFormControl = new win::Control();

ฉันไม่ทราบคำหลัก "เป็น" มาระยะหนึ่งแล้ว

MyClass myObject = (MyClass) obj;

VS

MyClass myObject = obj as MyClass;

อันที่สองจะคืนค่าว่างหาก obj ไม่ใช่ MyClass แทนที่จะส่งข้อยกเว้นการส่งคลาส

สองสิ่งที่ฉันชอบคือคุณสมบัติอัตโนมัติเพื่อให้คุณสามารถยุบรหัสของคุณลงไปอีก:

private string _name;
public string Name
{
    get
    {
        return _name;
    }
    set
    {
        _name = value;
    }
}

กลายเป็น

public string Name { get; set;}

ด้วยวัตถุเริ่มต้น:

Employee emp = new Employee();
emp.Name = "John Smith";
emp.StartDate = DateTime.Now();

กลายเป็น

Employee emp = new Employee {Name="John Smith", StartDate=DateTime.Now()}

คำหลัก 'เริ่มต้น' ในประเภททั่วไป:

T t = default(T);

ผลลัพธ์เป็น 'null' ถ้า T เป็นประเภทการอ้างอิงและ 0 ถ้าเป็น int, false ถ้าเป็นบูลีนและอื่น ๆ

คุณสมบัติทั่วไป แต่ส่วนมากของทั้งหมดDebuggerDisplay ประหยัดเวลาหลายปี

@ บอกคอมไพเลอร์เพื่อละเว้นอักขระเลี่ยงใด ๆ ในสตริง

แค่อยากจะอธิบายเรื่องนี้ ... มันไม่ได้บอกให้เพิกเฉยกับตัวละครหนีมันบอกให้คอมไพเลอร์แปลความหมายเป็นตัวอักษร

ถ้าคุณมี

string s = @"cat
             dog
             fish"

มันจะพิมพ์ออกมาเป็นจริง (โปรดทราบว่ามันยังมีช่องว่างที่ใช้สำหรับการเยื้อง):

cat
             dog
             fish

ผมคิดว่าหนึ่งในที่สุดภายใต้การชื่นชมและคุณลักษณะที่ไม่ค่อยมีคนรู้จักของ C # (NET 3.5) เป็นExpression ต้นไม้ , โดยเฉพาะอย่างยิ่งเมื่อรวมกับยาสามัญและ Lambdas นี่เป็นวิธีการในการสร้าง API ที่ไลบรารีใหม่เช่น NInject และ Moq กำลังใช้งานอยู่

ตัวอย่างเช่นสมมติว่าฉันต้องการลงทะเบียนวิธีด้วย API และ API นั้นต้องได้รับชื่อวิธี

รับคลาสนี้:

public class MyClass
{
     public void SomeMethod() { /* Do Something */ }
}

ก่อนหน้านี้มันเป็นเรื่องธรรมดามากที่จะเห็นนักพัฒนาทำสิ่งนี้ด้วยสตริงและประเภท (หรืออย่างอื่นที่ใช้สตริงเป็นหลัก):

RegisterMethod(typeof(MyClass), "SomeMethod");

นั่นมันแย่เพราะไม่มีพิมพ์ดีด ถ้าฉันเปลี่ยนชื่อ "SomeMethod" เป็นอย่างไร อย่างไรก็ตามใน 3.5 ฉันสามารถทำสิ่งนี้ในแบบที่พิมพ์ออกมาอย่างรุนแรง:

RegisterMethod<MyClass>(cl => cl.SomeMethod());

ซึ่งคลาส RegisterMethod ใช้Expression<Action<T>>ดังนี้:

void RegisterMethod<T>(Expression<Action<T>> action) where T : class
{
    var expression = (action.Body as MethodCallExpression);

    if (expression != null)
    {
        // TODO: Register method
        Console.WriteLine(expression.Method.Name);
    }
}

นี่เป็นเหตุผลสำคัญอย่างหนึ่งที่ฉันหลงรัก Lambdas และ Expression Trees ตอนนี้

" ผลผลิต " จะมาถึงใจของฉัน แอตทริบิวต์บางอย่างเช่น[DefaultValue ()]ก็เป็นหนึ่งในรายการโปรดของฉัน

"การvar " คำหลักที่เป็นที่รู้จักกันมากขึ้นอีกนิด แต่ที่คุณสามารถใช้มันใน .NET 2.0 การใช้งานเช่นกัน (ตราบใดที่คุณใช้ NET 3.5 คอมไพเลอร์และตั้งค่าการส่งออกรหัส 2.0) ดูเหมือนจะไม่เป็นที่รู้จักมาก ดี.

แก้ไข: kokos ขอบคุณสำหรับการชี้ให้เห็น ?? ผู้ประกอบการที่มีประโยชน์จริงๆ เพราะมันเป็นบิตยากที่จะ google มัน (ตาม ?? ถูกละเว้นเพียง) นี่คือหน้าเอกสารประกอบของ MSDN สำหรับผู้ประกอบการที่: ?? ผู้ประกอบการ (อ้างอิง C #)

ฉันมักจะพบว่านักพัฒนา C # ส่วนใหญ่ไม่รู้ประเภท 'nullable' โดยพื้นฐานแล้วดั้งเดิมที่สามารถมีค่า Null

double? num1 = null; 
double num2 = num1 ?? -100;

ตั้งค่า double ที่สามารถ null ได้, num1 , เป็น null จากนั้นตั้ง double ปกติ, num2 , เป็นnum1หรือ-100ถ้าnum1เป็น null

http://msdn.microsoft.com/en-us/library/1t3y8s4s(VS.80).aspx

อีกอย่างหนึ่งเกี่ยวกับประเภท Nullable:

DateTime? tmp = new DateTime();
tmp = null;
return tmp.ToString();

มันเป็นผลตอบแทน String.Empty ตรวจสอบลิงค์นี้สำหรับรายละเอียดเพิ่มเติม

นี่คือฟีเจอร์ C # ที่ซ่อนอยู่ที่น่าสนใจในรูปแบบของคีย์เวิร์ด C # ที่ไม่มีเอกสาร:

__makeref

__reftype

__refvalue

__arglist

คำเหล่านี้เป็นคำหลัก C # ที่ไม่มีเอกสาร (แม้แต่ Visual Studio รู้จักคำเหล่านั้น!) ซึ่งถูกเพิ่มเข้ามาเพื่อการชกมวย / unboxing ที่มีประสิทธิภาพมากขึ้นก่อนที่จะมีชื่อสามัญ พวกเขาทำงานประสานงานกับโครงสร้าง System.TypedReference

นอกจากนี้ยังมี __arglist ซึ่งใช้สำหรับรายการพารามิเตอร์ความยาวผันแปร

สิ่งหนึ่งที่ผู้คนไม่ค่อยรู้มากนักคือSystem.WeakReference - คลาสที่มีประโยชน์มากที่ติดตามวัตถุ แต่ยังอนุญาตให้ผู้รวบรวมขยะสามารถรวบรวมได้

คุณสมบัติ "ซ่อน" ที่มีประโยชน์มากที่สุดคือคีย์เวิร์ด return return มันไม่ได้ซ่อนจริงๆ แต่มีคนมากมายไม่รู้เกี่ยวกับมัน LINQ ถูกสร้างขึ้นบนยอดนี้; จะช่วยให้แบบสอบถามที่ดำเนินการล่าช้าโดยการสร้างเครื่องรัฐภายใต้ประทุน เรย์มอนด์เฉินเพิ่งโพสต์เกี่ยวกับภายในรายละเอียดทราย

ยูเนี่ยน (ประเภทหน่วยความจำแบบ C ++ ที่ใช้ร่วมกัน) อย่างแท้จริงปลอดภัย C #

โดยไม่ต้องหันไปใช้โหมดและพอยน์เตอร์ที่ไม่ปลอดภัยคุณสามารถให้สมาชิกคลาสแชร์พื้นที่หน่วยความจำในคลาส / โครงสร้าง รับคลาสต่อไปนี้:

[StructLayout(LayoutKind.Explicit)]
public class A
{
    [FieldOffset(0)]
    public byte One;

    [FieldOffset(1)]
    public byte Two;

    [FieldOffset(2)]
    public byte Three;

    [FieldOffset(3)]
    public byte Four;

    [FieldOffset(0)]
    public int Int32;
}

คุณสามารถปรับเปลี่ยนค่าของฟิลด์ไบต์ได้โดยจัดการฟิลด์ Int32 และในทางกลับกัน ตัวอย่างเช่นโปรแกรมนี้:

    static void Main(string[] args)
    {
        A a = new A { Int32 = int.MaxValue };

        Console.WriteLine(a.Int32);
        Console.WriteLine("{0:X} {1:X} {2:X} {3:X}", a.One, a.Two, a.Three, a.Four);

        a.Four = 0;
        a.Three = 0;
        Console.WriteLine(a.Int32);
    }

ผลลัพธ์นี้:

2147483647
FF FF FF 7F
65535

เพียงเพิ่มการใช้ System.Runtime.InteropServices;

ใช้ @ สำหรับชื่อตัวแปรที่เป็นคำหลัก

var @object = new object();
var @string = "";
var @if = IpsoFacto(); 

หากคุณต้องการออกจากโปรแกรมของคุณโดยไม่เรียกใช้บล็อกหรือFinalizersใด ๆ ให้ใช้FailFast :

Environment.FailFast()

การคืนค่าประเภทที่ไม่ระบุชื่อจากวิธีการและการเข้าถึงสมาชิกโดยไม่สะท้อน

// Useful? probably not.
private void foo()
{
    var user = AnonCast(GetUserTuple(), new { Name = default(string), Badges = default(int) });
    Console.WriteLine("Name: {0} Badges: {1}", user.Name, user.Badges);
}

object GetUserTuple()
{
    return new { Name = "dp", Badges = 5 };
}    

// Using the magic of Type Inference...
static T AnonCast<T>(object obj, T t)
{
   return (T) obj;
}

ต่อไปนี้เป็นประโยชน์สำหรับนิพจน์ทั่วไปและเส้นทางไฟล์:

"c:\\program files\\oldway"
@"c:\program file\newway"

@ บอกคอมไพเลอร์เพื่อละเว้นอักขระเลี่ยงใด ๆ ในสตริง

mixins โดยทั่วไปหากคุณต้องการเพิ่มคุณสมบัติให้กับหลาย ๆ คลาส แต่ไม่สามารถใช้หนึ่งคลาสพื้นฐานสำหรับทุกคลาสให้ใช้แต่ละคลาสเพื่อใช้อินเทอร์เฟซ (โดยไม่มีสมาชิก) จากนั้นเขียนวิธีการต่อเติมสำหรับส่วนต่อประสานเช่น

public static DeepCopy(this IPrototype p) { ... }

แน่นอนมีความชัดเจนบางอย่างเสียสละ แต่มันใช้งานได้!

ไม่แน่ใจว่าทำไมทุกคนถึงต้องการใช้ Nullable <bool> :-)

จริงเท็จ, FileNotFound ?

อันนี้ไม่ได้ "ซ่อน" มากนักเพราะมันผิด

ความสนใจจำนวนมากจ่ายให้กับอัลกอริทึม "แผนที่", "ลด" และ "ตัวกรอง" สิ่งที่คนส่วนใหญ่ไม่ทราบคือ. NET 3.5 ได้เพิ่มอัลกอริธึมทั้งสามเหล่านี้ แต่ให้ชื่อ SQL-ish มากโดยอิงจากข้อเท็จจริงที่ว่าพวกเขาเป็นส่วนหนึ่งของ LINQ

"map" => เลือก
แปลงข้อมูลจากแบบฟอร์มหนึ่งเป็นอีกแบบหนึ่ง

"ลด" => รวมผล
รวมค่าเป็นผลลัพธ์เดียว

"filter" => โดยที่
กรองข้อมูลตามเกณฑ์

ความสามารถในการใช้ LINQ ในการทำงานแบบอินไลน์กับคอลเลกชันที่ใช้ในการทำซ้ำและเงื่อนไขนั้นมีค่าอย่างไม่น่าเชื่อ มันคุ้มค่าที่จะเรียนรู้ว่าวิธีการขยาย LINQ ทั้งหมดสามารถช่วยทำให้โค้ดของคุณมีขนาดกะทัดรัดและสามารถบำรุงรักษาได้มากขึ้น

Environment.NewLine

สำหรับการขึ้นบรรทัดใหม่อิสระของระบบ

หากคุณกำลังพยายามใช้วงเล็บปีกกาภายในรูปแบบ String จัดรูปแบบ ...

int foo = 3;
string bar = "blind mice";
String.Format("{{I am in brackets!}} {0} {1}", foo, bar);
//Outputs "{I am in brackets!} 3 blind mice"

1. ?? - ผู้ประกอบการรวมตัวกัน
2. การใช้ ( คำสั่ง / คำสั่ง ) - คำหลักที่ยอดเยี่ยมที่สามารถใช้งานได้มากกว่าการโทรออก
3. อ่านอย่างเดียว - ควรใช้มากกว่านี้
4. netmodules - แย่มากไม่มีการสนับสนุนใน Visual Studio

@Ed ฉันรู้สึกประหม่าเล็กน้อยเกี่ยวกับการโพสต์สิ่งนี้เนื่องจากมันเป็นมากกว่า nitpicking เล็กน้อย อย่างไรก็ตามฉันจะชี้ให้เห็นว่าในตัวอย่างโค้ดของคุณ:

MyClass c;
  if (obj is MyClass)
    c = obj as MyClass

หากคุณกำลังจะใช้ 'คือ' ทำไมต้องติดตามด้วยนักแสดงที่ปลอดภัยโดยใช้ 'เป็น' หากคุณตรวจสอบว่า obj นั้นเป็น MyClass จริง ๆ แล้วตัวละครที่ได้มาตรฐาน

c = (MyClass)obj

... จะไม่ล้มเหลว

ในทำนองเดียวกันคุณสามารถพูดได้ว่า:

MyClass c = obj as MyClass;
if(c != null)
{
   ...
}

ฉันไม่รู้พอเกี่ยวกับอวัยวะภายในของ. NET เพื่อให้แน่ใจ แต่สัญชาตญาณของฉันบอกฉันว่าสิ่งนี้จะลดการดำเนินการปลดเปลื้องสูงสุดสองประเภทลงไปสูงสุด เป็นไปได้ยากที่จะทำลายธนาคารประมวลผลด้วยวิธีใดวิธีหนึ่ง โดยส่วนตัวแล้วฉันคิดว่ารูปแบบหลังดูสะอาดกว่าด้วย

อาจไม่ใช่เทคนิคขั้นสูง แต่อย่างหนึ่งที่ฉันเห็นตลอดเวลาที่ทำให้ฉันบ้า:

if (x == 1)
{
   x = 2;
}
else
{
   x = 3;
}

สามารถย่อไปที่:

x = (x==1) ? 2 : 3;