Це мені прийшло в голову після того, як я дізнався наступне з цього питання :

where T : struct

Ми, розробники C #, всі знаємо основи C #. Я маю на увазі декларації, умовні умови, цикли, оператори тощо.

Деякі з нас навіть освоїли такі речі, як Generics , анонімні типи , лямбда , LINQ , ...

Але які найпотаємніші особливості або хитрощі C #, про які навіть фанати C #, наркомани, експерти майже не знають?

Ось розкриті до цього часу функції:

Ключові слова

• yieldвід Michael Штум
• varвід Michael Штум
• using()заява кокоса
• readonlyпо KOKOS
• asвід Mike Stone
• as/ isавтор Ед Суангрен
• as/ is(покращено) Rocketpants
• defaultпо деатофрам
• global::від pzycoman
• using()блоки від AlexCuse
• volatileпо Якуб Šturc
• extern aliasпо Якуб Šturc

Атрибути

• DefaultValueAttributeвід Michael Штум
• ObsoleteAttributeавтор: DannySmurf
• DebuggerDisplayAttributeвід Стю
• DebuggerBrowsableі DebuggerStepThroughпо bdukes
• ThreadStaticAttributeпо marxidad
• FlagsAttributeавтор Мартін Кларк
• ConditionalAttributeпо AndrewBurns

Синтаксис

• ??(coalesce nulls) оператор kokos
• Числові позначення Ніка Берарді
• where T:newпо Lars Mæhlum
• Неявні генерики Кіта
• Однопараметричні лямбда від Кіта
• Автоматичні властивості від Keith
• Псевдоніми простору імен Кіта
• Дослівні рядкові букви з @ Патріком
• enumзначення по lfoust
• @variablenames від marxidad
• eventоператори марксидадом
• Форматуйте дужкові дужки від Portman
• Модифікатори доступності доступу до властивостей від xanadont
• Умовний (потрійний) оператор ( ?:) від JasonS
• checkedта uncheckedоператорів Біной Антоній
• implicit and explicitоператори від Flory

Мовні особливості

• Зменшувані типи Бреда Баркера
• Анонімні типи Кіт
• __makeref __reftype __refvalueавтор Юда Хіманго
• Об'єктні ініціалізатори lomaxx
• Форматування рядків Девіда в Дакоті
• Способи розширення марксидадом
• partialметоди Джон Еріксон
• Препроцесорні директиви Джона Асбека
• DEBUGпопередня директива Роберта Дургіна
• Перевантаження оператора SefBkn
• Введіть міркування по чекриту
• Булеві оператори , прийняті на наступний рівень по Rob Гоф
• Передайте змінну типу значення як інтерфейс без боксу Роман Бойко
• Програмно визначити оголошений тип змінної Романа Бойко
• Статичні конструктори Кріса
• Легше нанести на очі / ущільнити ORM-картографування за допомогою LINQ ростеронацидом
• __arglistвід Zac Боулінг

Особливості візуальної студії

• Виберіть блок тексту в редакторі Хімадрі
• Знімки від DannySmurf

Рамка

• TransactionScopeавтор: KiwiBastard
• DependantTransactionавтор: KiwiBastard
• Nullable<T>від IainMH
• Mutexвід Діаго
• System.IO.Pathза віковими заходами
• WeakReferenceвід Juan Manuel

Методи та властивості

• String.IsNullOrEmpty()метод КівіБастард
• List.ForEach()метод КівіБастард
• BeginInvoke(), EndInvoke()методи Вілл Дін
• Nullable<T>.HasValueта Nullable<T>.Valueвластивості Rismo
• GetValueOrDefaultметод Джона Шихана

Поради та рекомендації

• Хороший метод для організаторів подій Andreas HR Nilsson
• Великі порівняння Джона
• Отримайте доступ до анонімних типів без відображення dp
• Швидкий спосіб Ліниво властивостей колекції Instantiate по Волі
• JavaScript-подібні анонімні вбудовані функції від roosteronacid

Інший

• netmodules по KOKOS
• LINQBridge від Duncan Smart
• Parallel Extensions по Joel Coehoorn

Це не C # per 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, ви завжди можете повернути Lambdas, що робить Lambdas у сенсі функціонального програмування. Наприклад, ось лямбда, яка робить лямбда, яка обробляє подію 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) =>

Тепер я радий взяти клас функціонального програмування :-)

Окрім покажчиків на С, я думаю, що це інша фундаментальна річ, якій ви повинні навчитися :-)

Від Ріка Штраля :

Ви можете ланцюг ?? оператора, щоб ви могли здійснити купу нульових порівнянь.

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

Псевдонімічні дженерики:

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

Це дозволяє використовувати ASimpleNameзамість цього Dictionary<string, Dictionary<string, List<string>>>.

Використовуйте його, коли б ви використовували ту саму загальну велику довгу складну річ у багатьох місцях.

З CLR через C # :

При нормалізації рядків дуже рекомендується використовувати ToUpperInvariant замість ToLowerInvariant, оскільки Microsoft оптимізував код для порівняння великих літер .

Пам’ятаю, колись мій колега завжди міняв рядки на великі регістри перед порівнянням. Мені завжди було цікаво, чому він це робить, тому що я вважаю, що це "природніше" спочатку перетворитись на малі регістри. Прочитавши книгу зараз я знаю, чому.

Моя улюблена хитрість - використання оператора null coalesce та круглих дужок для автоматичної інстанцізації колекцій для мене.

private IList<Foo> _foo;

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

Уникайте перевірки наявних обробників подій

Додавання порожнього делегата до подій під час декларування, придушення необхідності завжди перевіряти подію на нуль, перш ніж називати її дивним. Приклад:

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

Будь ласка, також дивіться цю пов’язану дискусію та цю публікацію в блозі Еріка Ліпперта на цю тему (та можливі мінуси).

Все інше, плюс

1) неявна загальна інформація (чому тільки на методах, а не на заняттях?)

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

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

2) прості лямбдахи з одним параметром:

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

Дякую @pzycoman, що нагадав:

5) Псевдоніми простору імен (не те, що вам, можливо, знадобиться саме ця відмінність):

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;

проти

MyClass myObject = obj as MyClass;

Другий поверне null, якщо 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, якщо це булева, etcetera.

Атрибути загалом, але найбільше DebuggerDisplay . Економить вам роки.

@ Повідомляє компілятору ігнорувати будь-які символи в рядку.

Просто хотів уточнити цей ... він не говорить йому проігнорувати символи втечі, він фактично підказує компілятору інтерпретувати рядок як буквальний.

Якщо у вас є

string s = @"cat
             dog
             fish"

він фактично буде роздруковуватися як (зауважте, що він включає навіть пробіл, який використовується для відступу):

cat
             dog
             fish

Я думаю, що однією з найбільш недооцінених і менш відомих особливостей C # (.NET 3.5) є дерева виразів , особливо в поєднанні з Generics і 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);
    }
}

Це одна з головних причин того, що я зараз закоханий у лямбда і виразних дерев.

« урожайність » прийшла б мені на думку. Деякі з атрибутів, таких як [DefaultValue ()] , також є серед моїх улюблених.

Ключове слово " var " трохи більше відоме, але ви можете використовувати його і в .NET 2.0 додатках (доки ви використовуєте компілятор .NET 3.5 і встановите його для виведення коду 2.0), схоже, невідомо. добре.

Редагувати: kokos, дякую за вказівку ?? Оператор, це дійсно корисно. Оскільки для нього трохи важко google (оскільки ?? просто ігнорується), ось сторінка документації MSDN для цього оператора: ?? Оператор (довідка C #)

Я схильний вважати, що більшість розробників C # не знають про "нульові" типи. В основному, примітиви, які можуть мати нульове значення.

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

Встановіть нульовий подвійний, 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 їх розпізнає!), Які були додані для більш ефективного боксу / розпакування перед дженериками. Вони працюють узгоджено з системою System.TypedReference.

Є також __arglist, який використовується для списків параметрів змінної довжини.

Одне, про що люди мало знають - це System.WeakReference - дуже корисний клас, який відслідковує об’єкт, але все ще дозволяє сміттєзбірнику збирати його.

Найбільш корисною "прихованою" функцією буде ключове слово повернення доходу. Це насправді не приховано, але багато людей не знають про це. 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(); 

Якщо ви хочете вийти зі своєї програми, не викликаючи остаточних блоків або фіналізаторів, використовуйте 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"

@ Повідомляє компілятору ігнорувати будь-які символи в рядку.

Міксини. Якщо ви хочете додати функцію до декількох класів, але не можете використовувати один базовий клас для всіх, отримайте кожен клас для реалізації інтерфейсу (без членів). Потім запишіть метод розширення для інтерфейсу , тобто

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

Звичайно, деяка ясність приносять у жертву. Але це працює!

Не впевнений, чому хто-небудь хотів би використовувати Nullable <bool>, хоча. :-)

Правда, помилково, FileNotFound ?

Цей не так «прихований», як його неправильно називають.

Багато уваги приділяється алгоритмам «карта», «зменшення» та «фільтр». Більшість людей не розуміє, що .NET 3.5 додав усі три алгоритми, але він дав їм дуже імена SQL-ish, виходячи з того, що вони є частиною LINQ.

"map" => Вибрати
Перетворити дані з однієї форми в іншу

"зменшити" => Сукупність
Об'єднати значення агрегування в єдиний результат

"filter" => Де фільтрує
дані на основі критеріїв

Можливість використання LINQ для роботи на колекціях, які використовувались для ітерації та умовних умов, може бути надзвичайно цінною. Варто дізнатись, як усі методи розширення LINQ можуть допомогти зробити ваш код набагато компактнішим та рентабельнішим.

Environment.NewLine

для системних незалежних нових рядків.

Якщо ви намагаєтесь використовувати фігурні дужки у виразі String.Format ...

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. using ( заява / директива ) - відмінне ключове слово, яке можна використовувати не просто для виклику Dispose
3. тільки читати - слід використовувати більше
4. мережеві модулі - дуже погано, що у Visual Studio немає підтримки

@Ed, я трохи стриманий щодо розміщення цього запису, оскільки це трохи більше, ніж випивати. Однак я зазначу, що у вашому зразку коду:

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

Якщо ви збираєтесь використовувати "є", навіщо слідкувати за ним у безпечному ролях, використовуючи "as"? Якщо ви переконалися, що 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;