Bu sorudan aşağıdakileri öğrendikten sonra aklıma geldi :

where T : struct

Biz, C # geliştiricileri, hepimiz C # temellerini biliyoruz. Beyanlar, şartlar, döngüler, operatörler vb.

Bazılarımız Generics , anonim tipler , lambdas , LINQ , ...

Ancak C # hayranlarının, bağımlılarının, uzmanların bile zar zor bildiği en gizli özellikler veya C # numaraları nelerdir?

İşte şimdiye kadar ortaya çıkan özellikler:

Anahtar kelimeler

• yieldile Michael Stum
• varile Michael Stum
• using()kokos tarafından yapılan açıklama
• readonlykokos tarafından
• asile Mike Stone
• as/ Ed Swangrenis tarafından
• as/ is(geliştirildi) Rocketpants
• defaultdeathofrats tarafından
• global::pzycoman tarafından
• using()AlexCuse tarafından bloklar
• volatileile Jakub Šturc
• extern aliasile Jakub Šturc

Öznitellikler

• DefaultValueAttributeile Michael Stum
• ObsoleteAttributeDannySmurf tarafından
• DebuggerDisplayAttributeStu tarafından
• DebuggerBrowsableve bdukesDebuggerStepThrough tarafından
• ThreadStaticAttributemarxidad tarafından
• FlagsAttributeile Martin Clarke
• ConditionalAttributeAndrewBurns tarafından

Sözdizimi

• ??(coalesce nulls) operatör kokos tarafından
• Sayı işaretlerini Nick Berardi
• where T:newile Lars Mæhlum
• Örtülü jenerikler Keith tarafından
• Keith tarafından tek parametreli lambdas
• Keith tarafından otomatik özellikler
• Keith tarafından isim alanı takma adları
• @ İle Patrick kelimesi dizgi değişmezleri
• enumlfoust tarafından verilen değerler
• @variablenames yazan marxidad
• eventoperatörler marxidad tarafından
• Dize ayraçlarını Portman ile biçimlendirme
• Xanadont tarafından sağlanan mülk erişimi erişilebilirlik değiştiricileri
• Koşullu (üçlü) operatör ( ?:) JasonS tarafından
• checkedve uncheckedoperatörler Binoj Antony
• implicit and explicitOperatörler Flory

Dil özellikleri

• Brad Barker tarafından null olabilecek türler
• Keith tarafından anonim türleri
• __makeref __reftype __refvalueile Judah Himango
• Lomaxx tarafından nesne başlatıcılar
• Dizeleri Dakota'daki David tarafından biçimlendirin
• Marxidad tarafından Genişletme Yöntemleri
• partialyöntemleri Eric Erickson
• Önişlemci direktifleri John Asbeck
• DEBUGön işlemci yönergesi Robert Durgin
• Operatör aşırı yükleme SefBkn tarafından
• Chakrit tarafından yazılan çıkarım
• Rob Gough tarafından bir sonraki seviyeye alınan Boole operatörleri
• Roman Boiko'nun boks olmadan arayüz olarak değer tipi değişkenini iletme
• Bildirilen değişken türünün programsal olarak Roman Boiko tarafından belirlenmesi
• Statik Yapıcılar Chris
• Roosteronacid tarafından LINQ kullanılarak daha kolay göz / yoğun ORM eşlemesi
• __arglistile Zac Bowling

Visual Studio Özellikleri

• Himadri tarafından editördeki metin bloğunu seçin
• Snippet'ler DannySmurf tarafından

iskelet

• TransactionScopeKiwiBastard tarafından
• DependantTransactionKiwiBastard tarafından
• Nullable<T>IainMH tarafından
• MutexDiago tarafından
• System.IO.Pathageektrapped tarafından
• WeakReferenceile Juan Manuel

Yöntem ve Özellikleri

• String.IsNullOrEmpty()KiwiBastard yöntemi
• List.ForEach()KiwiBastard yöntemi
• BeginInvoke(), Will DeanEndInvoke() yöntemleri
• Nullable<T>.HasValueve RismoNullable<T>.Value özellikleri
• GetValueOrDefaultJohn Sheehan yöntemi

İpuçları & Hileler

• Andreas HR Nilsson'un olay işleyicileri için güzel bir yöntem
• John'un büyük harf karşılaştırmaları
• Dp tarafından yansımasız anonim türlere erişin
• Will tarafından toplama mülklerini tembel bir şekilde başlatmanın hızlı bir yolu
• Roosteronacid'den JavaScript benzeri anonim satır içi işlevler

Diğer

• netmodules yapan kokos
• Duncan Smart tarafından buzdolabı
• Paralel Uzantılar - Joel Coehoorn

Bu C # değil, ama gerçekten System.IO.Path.Combine()gerektiği kadar kullanan kimseyi görmedim . Aslında, tüm Path sınıfı gerçekten yararlıdır, ancak hiç kimse bunu kullanmaz!

Olmasa bile, her üretim uygulamasının aşağıdaki kodu içerdiğine bahse girmeye hazırım:

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

lambdalar ve tür çıkarımları önemsizdir. Lambdas birden fazla ifadeye sahip olabilir ve otomatik olarak uyumlu bir delege nesnesi olarak ikiye katlanır (sadece imza eşleştiğinden emin olun):

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

Unutmayın ve new CancellationEventHandlerne tür belirtmek zorunda değilim, senderve eonlar olaydan etkilenir. Bu nedenle, tüm delegate (blah blah)parametreleri yazmak için daha az kullanışlıdır ve bu da parametre türlerini belirtmenizi gerektirir.

Lambdas'ın bir şey döndürmesine gerek yoktur ve tür çıkarımı bu bağlamda son derece güçlüdür.

Ve BTW, her zaman Lambdas'ı işlevsel programlama anlamında yapan Lambdas'ı geri döndürebilirsiniz . Örneğin, bir Button'ı işleyen bir lambda yapan bir lambda.

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

Zincire dikkat edin: (dx, dy) => (sender, e) =>

İşte bu yüzden fonksiyonel programlama dersini almış olmaktan mutluluk duyuyorum :-)

C işaretçiler dışında, bence öğrenmeniz gereken diğer temel şey :-)

Gönderen Rick Strahl :

Zincir olabilir ?? bir dizi boş karşılaştırma yapabilmeniz için kullanılır.

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

Takma jenerikler:

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

Bunun ASimpleNameyerine kullanmanıza izin verir Dictionary<string, Dictionary<string, List<string>>>.

Birçok yerde aynı jenerik büyük uzun karmaşık şeyi kullanacağınız zaman kullanın.

Gönderen C # yoluyla CLR :

Dizeleri normalleştirirken, Microsoft büyük harfli karşılaştırmalar yapmak için kodu optimize ettiği için ToLowerInvariant yerine ToUpperInvariant kullanmanız önemle tavsiye edilir .

İş arkadaşımın karşılaştırma yapmadan önce her zaman dizeleri büyük harfe değiştirdiğini hatırlıyorum. Bunu neden yaptığını hep merak ettim çünkü önce küçük harfe dönüştürmenin daha "doğal" olduğunu hissediyorum. Şimdi kitabı okuduktan sonra nedenini biliyorum.

En sevdiğim numara koleksiyonları otomatik olarak başlatmak için null birleştirme operatörü ve parantez kullanmak.

private IList<Foo> _foo;

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

Boş olay işleyicilerini denetlemekten kaçının

Beyan sırasındaki olaylara boş bir delege eklemek, olayı çağırmadan önce her zaman null olup olmadığını kontrol etme gereğini bastırmak harika. Misal:

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

Bunu yapmana izin ver

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

Bunun yerine

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

Lütfen bu konuyla ilgili ve Eric Lippert'in bu konudaki (ve olası dezavantajları) ilgili blog yayınına da bakın .

Diğer her şey, artı

1) örtük jenerikler (neden sınıflar üzerinde değil, sadece yöntemler üzerinde?)

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

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

2) bir parametre ile basit lambdas:

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

3) isimsiz türler ve başlatıcılar:

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

Bir diğeri:

4) Otomatik özellikler farklı kapsamlara sahip olabilir:

public int MyId { get; private set; }

Bana hatırlattığın için teşekkürler @pzycoman:

5) Ad alanı takma adları (bu özel ayırıma ihtiyacınız olması gerekmez):

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

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

Bir süredir "as" anahtar kelimesini bilmiyordum.

MyClass myObject = (MyClass) obj;

vs

MyClass myObject = obj as MyClass;

İkincisi, bir sınıf cast istisnası atmak yerine obj bir MyClass değilse null değerini döndürür.

Sevdiğim iki şey Otomatik özelliklerdir, böylece kodunuzu daha da daraltabilirsiniz:

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

olur

public string Name { get; set;}

Ayrıca nesne başlatıcılar:

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

olur

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

Genel türlerde 'varsayılan' anahtar kelime:

T t = default(T);

T bir başvuru türüyse 'null', int ise 0, boolean ise false vb. ile sonuçlanır.

Genel olarak öznitelikler, ancak çoğu DebuggerDisplay . Size yıllar kazandırır.

@ Derleyiciye bir dizede kaçış karakterini yoksaymasını söyler.

Sadece bunu açıklığa kavuşturmak istedim ... kaçış karakterlerini görmezden gelmesini söylemez, derleyiciye dizeyi değişmez olarak yorumlamasını söyler.

Eğer varsa

string s = @"cat
             dog
             fish"

aslında şu şekilde yazdırılacaktır (girinti için kullanılan boşlukları bile içerdiğini unutmayın):

cat
             dog
             fish

C # (.NET 3.5) en az bilinen ve daha az bilinen özelliklerinden biri , özellikle Generics ve Lambdas ile birleştirildiğinde İfade Ağaçları olduğunu düşünüyorum. Bu, NInject ve Moq gibi daha yeni kitaplıkların kullandığı API oluşturmaya yönelik bir yaklaşımdır.

Örneğin, bir yöntemi bir API ile kaydetmek istediğimi ve API'nın yöntem adını alması gerektiğini varsayalım

Bu sınıf verildiğinde:

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

Daha önce, geliştiricilerin bunu dizelerle ve türlerle (veya büyük ölçüde dize tabanlı başka bir şeyle) yaptıklarını görmek çok yaygındı:

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

Güçlü yazma eksikliği yüzünden berbat. "SomeMethod" adını değiştirirsem ne olur? Şimdi, 3.5'te, bunu güçlü bir şekilde yazabilirim:

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

RegisterMethod sınıfının şu şekilde kullandığı 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);
    }
}

Şu anda Lambdas ve İfade Ağaçları'na aşık olmamın büyük bir nedeni bu.

aklıma " verim " gelirdi. [DefaultValue ()] gibi bazı özellikler de favorilerim arasında.

" Var " anahtar sözcüğü biraz daha bilinir, ancak .NET 2.0 uygulamalarında da kullanabilirsiniz (.NET 3.5 derleyicisini kullandığınız ve 2.0 koduna ayarladığınız sürece) çok bilinmemektedir. iyi.

Düzenleme: kokos, işaret ettiğiniz için teşekkürler ?? gerçekten yararlı. Bunun için google için biraz zor olduğundan (?? sadece yok sayılır gibi), işte o operatör için MSDN dokümantasyon sayfası: ?? Operatör (C # Referansı)

Çoğu C # geliştiricisinin 'nullable' türlerini bilmediğini fark etme eğilimindeyim. Temel olarak, sıfır değerine sahip olabilen ilkeller.

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

Bir null çift, Set num1 null, ardından normal bir çift, set NUM2 için, NUM1 veya -100 eğer num1 boş oldu.

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

Nullable türü hakkında bir şey daha:

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

döndürür String.Empty. Daha fazla ayrıntı için bu bağlantıyı kontrol edin

Belgesiz C # anahtar kelimeleri şeklinde bazı ilginç gizli C # özellikleri:

__makeref

__reftype

__refvalue

__arglist

Bunlar, jeneriklerden önce daha verimli bir boks / kutudan çıkarma için eklenen belgesiz C # anahtar kelimeleridir (hatta Visual Studio bunları tanır!). System.TypedReference yapısı ile koordineli olarak çalışırlar.

Ayrıca değişken uzunluklu parametre listeleri için kullanılan __arglist vardır.

İnsanların pek bilmediği bir şey System.WeakReference - bir nesneyi takip eden ancak çöp toplayıcının onu toplamasına izin veren çok kullanışlı bir sınıftır.

En yararlı "gizli" özellik, getiri anahtar kelimesi olacaktır. Gerçekten gizli değil, ama birçok insan bunu bilmiyor. LINQ bunun üzerine inşa edilmiştir; kaputun altında bir durum makinesi oluşturarak gecikmeli olarak yürütülen sorgulara izin verir. Raymond Chen geçtiğimiz günlerde içten gelen cesur ayrıntılardan bahsetti .

Saf, güvenli C # içindeki sendikalar (C ++ paylaşılan bellek türü)

Güvenli olmayan moda ve işaretlere başvurmadan, sınıf üyelerinin bir sınıf / yapıdaki bellek alanını paylaşmasını sağlayabilirsiniz. Aşağıdaki sınıf verildiğinde:

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

Bayt alanlarının değerlerini Int32 alanını ve tam tersini değiştirerek değiştirebilirsiniz. Örneğin, bu program:

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

Bunu çıktılar:

2147483647
FF FF FF 7F
65535

sadece System.Runtime.InteropServices kullanarak ekleyin;

Anahtar kelime olan değişken adları için @ kullanma.

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

Sonunda herhangi bir blok veya sonlandırıcı çağırmadan programınızdan çıkmak istiyorsanız FailFast kullanın :

Environment.FailFast()

Bir yöntemden anonim türler döndürme ve yansıma olmadan üyelere erişme.

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

Normal ifadeler ve dosya yolları için kullanışlı bir yöntem:

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

@ Derleyiciye bir dizede kaçış karakterini yoksaymasını söyler.

Katmalar. Temel olarak, birkaç sınıfa bir özellik eklemek istiyorsanız, ancak hepsi için bir temel sınıf kullanamıyorsanız, her sınıfı bir arabirim (üyesiz) uygulamak için alın. Daha sonra, bir uzantısı yöntem bilgileri arabirimi için , yani,

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

Tabii ki, bir miktar netlik feda edilir. Ama işe yarıyor!

Neden hiç kimse Nullable <bool> kullanmak isteyeyim emin değilim. :-)

Doğru, Yanlış, FileNotFound ?

Bu, isimlendirildiği kadar "gizli" değildir.

"Harita", "azalt" ve "filtre" algoritmalarına çok dikkat edilir. Çoğu insanın fark etmediği şey, .NET 3.5'in bu algoritmaların üçünü de eklemesidir, ancak LINQ'nun bir parçası olmalarına dayanarak onlara çok SQL ish isimleri verdi.

"map" => Seç
Verileri bir formdan diğerine dönüştürür

"reduce" => Toplam
Toplama Değerleri tek bir sonuçta toplar

"filter" => Nerede
Verileri ölçütlere göre filtreler

LINQ'yu yineleme ve koşullu olarak kullanılan koleksiyonlar üzerinde satır içi çalışma yapmak için kullanma becerisi inanılmaz derecede değerli olabilir. Tüm LINQ genişletme yöntemlerinin kodunuzu çok daha kompakt ve bakımı kolay hale getirmeye nasıl yardımcı olabileceğini öğrenmeye değer.

Environment.NewLine

sistemden bağımsız yeni satırlar için.

Bir String.Format ifadesinin içinde süslü parantez kullanmaya çalışıyorsanız ...

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. ??- birleştirme operatörü
2. using ( deyim / yönerge ) - Dispose'i çağırmaktan daha fazlası için kullanılabilecek harika anahtar kelime
3. salt okunur - daha fazla kullanılmalıdır
4. netmodules - çok kötü Visual Studio'da destek yok

@Ed, nitpicking'dan biraz daha fazlası olduğu için bunu yayınlamak konusunda biraz duraksamıyorum. Ancak, ben kod örnekte işaret:

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

'İs' kullanacaksanız, neden 'as' kullanarak güvenli bir oyuncu ile takip edesiniz? Nesnenin gerçekten de MyClass olduğunu tespit ettiyseniz, bataklık standardı bir oyuncu kadrosu:

c = (MyClass)obj

... asla başarısız olmayacak.

Benzer şekilde, sadece şunu söyleyebilirsiniz:

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

Emin olmak için .NET'in innards hakkında yeterli bilmiyorum, ama içgüdülerim bana bunun en fazla iki tip döküm işlemini en fazla bire indireceğini söylüyor. İşleme bankasını her iki şekilde de kırmak pek olası değildir; şahsen, ikinci formun da daha temiz göründüğünü düşünüyorum.

Belki ileri bir teknik değil, ama her zaman gördüğüm bir şey beni deli ediyor:

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

yoğunlaştırılabilir:

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