Это не С# per se, но я не видел никого, кто действительно использует System.IO.Path.Combine() в той степени, в которой они должны. На самом деле весь класс Path действительно полезен, но никто его не использует!

Я готов поспорить, что каждое производственное приложение имеет следующий код, хотя он не должен:

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

lambdas и тип inferrence недооцениваются. Lambdas может иметь несколько операторов, и они удваиваются как совместимый объект-делегат автоматически (просто убедитесь, что подпись соответствует), как в:

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

Обратите внимание, что у меня нет new CancellationEventHandler, и я не должен указывать типы sender и e, они выводятся из события. Вот почему это менее громоздко для записи всего delegate (blah blah), в котором также требуется указать типы параметров.

Lambdas не нужно возвращать что-либо, а вывод типа чрезвычайно силен в таком контексте.

И 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) =>

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

Помимо указателей на C, я думаю, что это другая фундаментальная вещь, которую вы должны изучить: -)

Из Рик Стралл:

Вы можете связать?? оператора, чтобы вы могли выполнить нулевое сравнение.

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

От CLR через С#:

При нормализации строк это очень рекомендуется использовать ToUpperInvariant вместо ToLowerInvariant, потому что Microsoft имеет оптимизировал код для выполнения сравнение в верхнем регистре.

Я помню, как однажды мой коллега всегда менял строки в верхнем регистре, прежде чем сравнивать. Я всегда задавался вопросом, почему он это делает, потому что я чувствую себя более "естественным", чтобы сначала преобразовать в нижний регистр. После прочтения книги я знаю почему.

Псевдонимы:

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

Это позволяет использовать ASimpleName вместо Dictionary<string, Dictionary<string, List<string>>>.

Используйте его, когда вы будете использовать одну и ту же общую большую длинную сложную вещь во многих местах.

Мой любимый трюк использует оператор null coalesce и круглые скобки для автоматического создания экземпляров для меня.

private IList<Foo> _foo;

public IList<Foo> ListOfFoo 
    { get { return _foo ?? (_foo = new List<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();

Избегайте проверки нулевых обработчиков событий

Добавление пустого делегата к событиям в объявлении, подавляющее необходимость всегда проверять событие для 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");
    }
}

Также см. обсуждение , и этот сообщение в блоге Эрика Липперта на эту тему (и возможные недостатки).

Я не знал ключевое слово "как" довольно долгое время.

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

Ключевое слово default по умолчанию:

T t = default(T);

приводит к "null", если T является ссылочным типом, а 0, если он является int, false, если он является логическим, и так далее.

Я думаю, что одна из самых недооцененных и менее известных функций С# (.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);
    }
}

Это одна из главных причин того, что я сейчас люблю Лямбда и Деревни Expression.

Атрибуты вообще, но больше всего DebuggerDisplay. Экономит ваши годы.

" yield" придет мне на ум. Некоторые из таких атрибутов, как [DefaultValue()], также относятся к моим фаворитам.

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

Редактировать: kokos, спасибо, что указали??? оператора, что действительно действительно полезно. Так как это немного сложно для Google (так как это просто игнорируется), вот страница документации MSDN для этого оператора: ?? Оператор (ссылка на С#)

Команда @сообщает компилятору игнорировать любые escape-символы в строке.

Просто хотел прояснить это... он не говорит ему игнорировать escape-символы, он на самом деле говорит компилятору интерпретировать строку как литерал.

Если у вас

string s = @"cat
             dog
             fish"

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

cat
             dog
             fish

Вот некоторые интересные скрытые функции С# в виде недокументированных ключевых слов С#:

__makeref

__reftype

__refvalue

__arglist

Это недокументированные ключевые слова С# (даже Visual Studio их распознает!), которые были добавлены для более эффективного бокса/распаковки до дженериков. Они работают в координации с структурой System.TypedReference.

Здесь также __arglist, который используется для списков параметров переменной длины.

Одна вещь, о которой люди мало знают, - это System.WeakReference - очень полезный класс, который отслеживает объект, но все же позволяет сборщик мусора, чтобы собрать его.

Наиболее полезной "скрытой" функцией будет ключевое слово yield yield. Это действительно не скрыто, но многие люди об этом не знают. LINQ построен поверх этого; он позволяет выполнять запросы с задержкой, создавая конечный автомат под капотом. Недавно Раймонд Чен опубликовал информацию о внутренних подробных подробностях.

Я обычно обнаруживаю, что большинство разработчиков С# не знают о типах "nullable". В принципе, примитивы, которые могут иметь нулевое значение.

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

Задайте значение nullable double, num1, null, затем установите регулярные двойные, num2, num1 или -100, если num1 был нулевым.

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

еще одна вещь о типе Nullable:

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

возвращает String.Empty. Проверьте эту ссылку для более подробной информации

Союзы (тип разделяемой памяти С++) в чистом, безопасном С#

Не прибегая к небезопасному режиму и указателям, вы можете иметь членов класса, разделяющих пространство памяти в классе/структуре. Учитывая следующий класс:

[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"

@сообщает компилятору игнорировать любые escape-символы в строке.

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

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

Конечно, некоторая ясность приносится в жертву. Но это работает!

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

Правда, False, FileNotFound?

Этот не скрыт настолько, насколько это неправильно.

Большое внимание уделяется алгоритмам "карта", "уменьшение" и "фильтр". Большинство людей не понимают, что .NET 3.5 добавил все три из этих алгоритмов, но он дал им очень SQL-иш имена, основанные на том, что они являются частью LINQ.

"map" = > Выбрать
Преобразовать данные из одной формы в другую

"уменьшить" = > Агрегат агрегатов значения в один результат

"filter" = > Где
Фильтры на основе критериев

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

Если вы пытаетесь использовать фигурные скобки внутри выражения 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"

Environment.NewLine

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

• ? - коалесцирующий оператор
• используя (statement/директива) - отличное ключевое слово, которое можно использовать не только для вызова Dispose
• readonly - следует использовать больше
• netmodules - слишком плохо там нет поддержки в Visual Studio

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

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

Если вы собираетесь использовать "is", зачем следить за ним с помощью безопасного броска, используя "как"? Если вы установили, что 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;

Многие люди не понимают, что они могут сравнивать строки, используя: OrdinalIgnoreCase вместо того, чтобы делать someString.ToUpper(). Это устраняет дополнительные накладные расходы на строку.

if( myString.ToUpper() == theirString.ToUpper() ){ ... }

становится

if( myString.Equals( theirString, StringComparison.OrdinalIgnoreCase ) ){ ... }

Только что выученные анонимные типы могут вывести имена свойств из имени переменной:

string hello = "world";
var o = new { hello };
Console.WriteLine(o.hello);

Мне нравится искать вещи в списке вроде: -

bool basketContainsFruit(string fruit) {
  return new[] { "apple", "orange", "banana", "pear" }.Contains(fruit);
}

Вместо: -

bool basketContainsFruit(string fruit) {
  return fruit == "apple" || fruit == "orange" || fruit == "banana" ||
    fruit == "pear";
}

На практике это не так много, но идея сопоставления предметов с объектом поиска может быть очень полезной и кратким.

Я выбрал это при использовании ReSharper:

Неявное преобразование групп методов

//If given this:
var myStrings = new List<string>(){"abc","def","xyz"};
//Then this:
myStrings.ForEach(s => Console.WriteLine(s));
//Is equivalent to this:
myStrings.ForEach(Console.WriteLine);

См. " Преобразование группы неявных методов в С#" для более.

Вот новый метод строкового класса в С# 4.0:

String.IsNullOrWhiteSpace(String value)

Это о времени.

Честно говоря, эксперты по самому определению должны знать этот материал. Но чтобы ответить на ваш вопрос: Таблица встроенных типов (ссылка на С#)

Знак компилятора для чисел широко известен для них:

Decimal = M
Float = F
Double = D

// for example
double d = 30D;

Однако они более неясны:

Long = L
Unsigned Long = UL
Unsigned Int = U

• TransactionScope и DependentTransaction в System.Transactions - облегченный способ использования обработки транзакций в .NET - это не только для транзакции базы данных или
• String.IsNullOrEmpty - это тот, который я удивлен, узнав, что многие разработчики не знают о
• List.ForEach - итерация через общий список с использованием метода делегата

Есть больше, но это три очевидные вершины моей головы...

InternalsVisibleTo атрибут - это тот, который не так хорошо известен, но может быть легко доступен в определенные обстоятельства. Это в основном позволяет другой сборке иметь доступ к "внутренним" элементам определяющей сборки.

Dictionary.TryGetValue(клавиша K, выходное значение V)

Работает как чек и входит в один. Вместо <

if(dictionary.ContainsKey(key)) 
{
    value = dictionary[key];
    ...
}

вы можете просто сделать;

if(dictionary.TryGetValue(key, out value)) 
{ ... }

и значение установлено.

При отладке вы можете ввести $exception в окне Watch\QuickWatch\Immediate и получить всю информацию об исключении текущего фрейма. Это очень полезно, если у вас есть исключения 1-го случая!

Условная строка .Format:

Применяет различное форматирование к числу в зависимости от того, является ли число положительным, отрицательным или нулевым.

string s = string.Format("{0:positive;negative;zero}", i);

например.

string format = "000;-#;(0)";

string pos = 1.ToString(format);     // 001
string neg = (-1).ToString(format);  // -1
string zer = 0.ToString(format);     // (0)

События действительно являются делегатами под капотом, и любой объект-делегат может иметь к нему несколько функций и выделяться из него с помощью операторов + = и-= соответственно.

События также могут управляться с помощью add/remove, аналогично get/set, за исключением того, что они вызывается, когда используются + = и - =:

public event EventHandler SelectiveEvent(object sender, EventArgs args) 
  { add 
     { if (value.Target == null) throw new Exception("No static handlers!");
       _SelectiveEvent += value;
     }
    remove
     { _SelectiveEvent -= value;
     }
  } EventHandler _SelectiveEvent;

Больше функции времени исполнения, но я недавно узнал, что есть два сборщика мусора. Рабочая станция gc и сервер gc. Рабочая станция по умолчанию используется для клиентских версий окон, но сервер работает намного быстрее на многоядерных машинах.

<configuration>
   <runtime>
      <gcServer enabled="true"/>
   </runtime>
</configuration>

Будьте осторожны. Сервер gc требует больше памяти.

Не забывайте о перейти.

Другие недоиспользуемые операторы checked и unchecked:

short x = 32767;   // 32767 is the max value for short
short y = 32767;
int z1 =  checked((short)(x + y));   //will throw an OverflowException
int z2 =  unchecked((short)(x + y)); // will return -2
int z3 =  (short)(x + y);            // will return -2

Использовать "throw" ; вместо "throw ex" ; для сохранения трассировки стека

Если повторное бросание исключения без добавления дополнительной информации, используйте "throw" вместо "throw ex" . Пустой оператор "throw" в блоке catch будет испускать определенный IL, который повторно генерирует исключение, сохраняя исходную трассировку стека. "throw ex" теряет трассировку стека к исходному источнику исключения.

Я не мог видеть это выше - тот, который я не понимал, что вы могли бы сделать до недавнего времени, - это вызвать один конструктор из другого:

class Example
{
    public Example(int value1)
        : this(value1, "Default Value")
    {
    }

    public Example(int value1, string value2)
    {
        m_Value1 = value1;
        m_value2 = value2;
    }

    int m_Value1;
    string m_value2;
}

Я просто хотел скопировать этот код без комментариев. Итак, фокус в том, чтобы просто нажать кнопку Alt, а затем выделить прямоугольник, который вам нравится (например, ниже).

protected void GridView1_RowCommand(object sender, GridViewCommandEventArgs e)
    {
        //if (e.CommandName == "sel")
        //{
        //    lblCat.Text = e.CommandArgument.ToString();
        //}
    }

В приведенном выше коде, если я хочу выбрать:

e.CommandName == "sel"

lblCat.Text = e.Comman

Затем я нажимаю клавишу ALt и выбираю прямоугольник и не нужно раскомментировать строки.

Проверьте это.

Несколько скрытых функций, с которыми я столкнулся:

• stackalloc, который позволяет выделять массивы в стеке
• Анонимные методы без явного списка параметров, которые неявно конвертируются в любой тип делегата с параметрами non-out/ref (очень удобны для событий, как отмечено в более раннем комментарии).
• Многие люди не знают, что такое события (добавьте/удалите пару методов, например get/set для свойств); полевые события в С# действительно объявляют как переменную, так и событие
• Операторы == и != могут быть перегружены, чтобы возвращать типы, отличные от bool. Странно, но верно.
• Трансляция выражения запроса в С# 3 действительно "прост" в некотором роде - это означает, что вы можете заставить ее сделать очень странные вещи.
• У Nullable типов есть специальное поведение в боксе: нулевое значение попадает в нулевую ссылку, и вы также можете отменить ненулевое значение с нулевым типом.

Ключевое слово params, т.е.

public void DoSomething(params string[] theStrings)
{
  foreach(string s in theStrings)
  {
    // Something with the Strings…
  }
}

Вызывается как

DoSomething("The", "cat", "sat", "on", "the" ,"mat");

Несколько вещей, которые мне нравятся:

-Если вы создаете интерфейс, похожий на

 public interface SomeObject<T> where T : SomeObject<T>, new()

вы вынуждаете все, что наследует от этого интерфейса, к содержат конструктор без параметров. Это очень полезно для пару вещей, с которыми я столкнулся.

- использование анонимных типов для создания полезного объекта "на лету":

var myAwesomeObject = new {Name="Foo", Size=10};

-Наконец, многие разработчики Java знакомы с синтаксисом вроде:

public synchronized void MySynchronizedMethod(){}

Однако в С# это недопустимый синтаксис. Обходной путь - это атрибут метода:

 [MethodImpl(MethodImplOptions.Synchronized)]
 public void MySynchronizedMethod(){}

@Давид в Дакоте:

Console.WriteLine( "-".PadRight( 21, '-' ) );

Я использовал это, пока не обнаружил, что класс String имеет конструктор, который позволяет вам сделать то же самое более чистым способом:

new String('-',22);

Статические конструкторы.

Экземпляры:

public class Example
{
    static Example()
    {
        // Code to execute during type initialization
    }

    public Example()
    {
        // Code to execute during object initialization
    }
}

Статические классы:

public static class Example
{
    static Example()
    {
        // Code to execute during type initialization
    }
}

MSDN говорит:

Статический конструктор используется для инициализации любых статических данных или для выполнения определенного действия, которое требуется выполнить только один раз. Он вызывается автоматически до создания первого экземпляра или ссылки на любые статические члены.

Например:

public class MyWebService
{
    public static DateTime StartTime;

    static MyWebService()
    {
        MyWebService.StartTime = DateTime.Now;
    }

    public TimeSpan Uptime
    {
        get { return DateTime.Now - MyWebService.StartTime; }
    }
}

Но вы могли бы так же легко сделать:

public class MyWebService
{
    public static DateTime StartTime = DateTime.Now;

    public TimeSpan Uptime
    {
        get { return DateTime.Now - MyWebService.StartTime; }
    }
}

Поэтому вам будет трудно найти какой-либо экземпляр, когда вам действительно нужно использовать статический конструктор.

MSDN предлагает полезные заметки о статических конструкторах:

• Статический конструктор не принимает модификаторы доступа или не имеет параметров.

• Статический конструктор вызывается автоматически для инициализации класса до создания первого экземпляра
  или любые статические члены ссылаются.

• Статический конструктор нельзя вызвать напрямую.

• Пользователь не может контролировать, когда статический конструктор выполняется в Программа.

• Типичное использование статических конструкторов - это когда класс используя файл журнала и конструктор используется для записи
  записи в этот файл.

• Статические конструкторы также полезны при создании классов-оболочек для
  неуправляемый код, когда конструктор
  может вызвать метод LoadLibrary.

• Если статический конструктор генерирует исключение, время выполнения не будет вызывать его второй раз, а тип останутся неинициализированными для время жизни домена приложения в который работает в вашей программе.

Самое главное отметить, что если в статическом конструкторе возникает ошибка, вызывается TypeIntializationException, и вы не можете переходить к строке нарушения кода. Вместо этого вам нужно изучить член TypeInitializationException InnerException, который является конкретной причиной.

volatile, чтобы сообщить компилятору, что поле может быть изменено несколькими потоками одновременно.

Foreach использует Duck Typing

Перефразируя или бесстыдно крадя из Krzysztof Cwalinas blog об этом. Более интересные мелочи, чем что-либо.

Для поддержки вашего объекта foreach вам не нужно реализовывать IEnumerable. То есть это не ограничение и не проверяется компилятором. Проверено, что

• Ваш объект предоставляет общедоступный метод GetEnumerator, который
  • не принимает параметров
  • возвращает тип, состоящий из двух элементов
    • безпараметрический метод MoveNext, который возвращает логическое
    • свойство Current with getter, возвращающее объект

Например,

class Foo
{
    public Bar GetEnumerator() { return new Bar(); }

    public struct Bar
    {
        public bool MoveNext()
        {
            return false;
        }

        public object Current
        {
            get { return null; }
        }
    }
}

// the following complies just fine:
Foo f = new Foo();
foreach (object o in f)
{
    Console.WriteLine("Krzysztof Cwalina da man!");
}

С# + CLR:

• Thread.MemoryBarrier: Большинство людей не использовало бы его, и в MSDN есть некоторая неточная информация. Но если вы знаете intricacies, вы можете сделать отличную синхронизацию без блокировки.

• volatile, Thread.VolatileRead, Thread.VolatileWrite: Очень мало людей, которые пользуются этим и даже меньше, кто понимает все риски, которых они избегают и вводят:).

• ThreadStatic переменные: за последние несколько лет была только одна ситуация, и я обнаружил, что переменные ThreadStatic были абсолютно посланы и необходимы. Например, если вы хотите что-то сделать для всей цепочки вызовов, они очень полезны.

• fixed keyword: это скрытое оружие, когда вы хотите сделать доступ к элементам большого массива почти так же быстро, как С++ (по умолчанию С# принудительно привязывает проверки, что замедляет работу).

• default(typeName) ключевое слово может использоваться и вне родового класса. Полезно создать пустую копию структуры.

• Одна из удобных функций, которые я использую, DataRow[columnName].ToString() всегда возвращает ненулевое значение. Если значение в базе данных было NULL, вы получаете пустую строку.

• Использовать объект Debugger для автоматического разрыва, если вы хотите привлечь внимание разработчика, даже если он/она не включили автоматическое прерывание исключения:

#if DEBUG  
    if (Debugger.IsAttached)  
        Debugger.Break();  
#endif

8. Вы можете использовать сложные сложные уродливые общие типы, поэтому вам не нужно копировать их снова и снова. Также вы можете вносить изменения в этот тип в одном месте. Например,

    using ComplicatedDictionary = Dictionary<int, Dictionary<string, object>>;
    ComplicatedDictionary myDictionary = new ComplicatedDictionary();

Затворы

Поскольку анонимные делегаты были добавлены в 2.0, мы смогли разработать закрытие. Они редко используются программистами, но предоставляют большие преимущества, такие как немедленное повторное использование кода. Рассмотрим этот фрагмент кода:

bool changed = false;

if (model.Prop1 != prop1)
{
    changed = true;
    model.Prop1 = prop1;
}
if (model.Prop2 != prop2)
{
    changed = true;
    model.Prop2 = prop2;
}
// ... etc. 

Обратите внимание, что приведенные выше if-инструкции выполняют аналогичные фрагменты кода, за исключением одной строки кода, т.е. устанавливают разные свойства. Это можно укоротить следующим: где переменная строка кода вводится как параметр в объект Action, соответствующий названию setAndTagChanged:

bool changed = false;
Action<Action> setAndTagChanged = (action) => 
{ 
    changed = true; 
    action(); 
};

if (model.Prop1 != prop1) setAndTagChanged(() => model.Prop1 = prop1);
if (model.Prop2 != prop2) setAndTagChanged(() => model.Prop2 = prop2);

Во втором случае замыкание позволяет вам охватить переменную change в вашей лямбда, что является кратким способом подхода к этой проблеме.

Альтернативный способ заключается в использовании другой неиспользуемой функции, "или равного" оператора двоичного присваивания. Следующий код показывает, как:

private bool conditionalSet(bool condition, Action action)
{
    if (condition) action();
    return condition;
}

// ...

bool changed = false;
changed |= conditionalSet(model.Prop1 == prop1, () => model.Prop1 = prop1);
changed |= conditionalSet(model.Prop2 == prop2, () => model.Prop2 = prop2);

Несколько других атрибутов из пространства имен System.Diagnostics весьма полезны.

DebuggerBrowsable позволит вам скрыть переменные из окна отладчика (мы используем его для всех частных резервных переменных открытых свойств). Наряду с этим DebuggerStepThrough заставляет отладчик перешагивать этот код, очень полезный для немых свойств (возможно, он должен быть преобразован в авто-свойства, если вы можете взять зависимость от компилятора С# 3.0). В качестве примера

[DebuggerBrowsable(DebuggerBrowsableState.Never)]
private string nickName;
public string NickName    {
    [DebuggerStepThrough]
    get { return nickName; }
    [DebuggerStepThrough]
    set { this.nickName = value; }
}

Я бы сказал, что использование некоторых системных классов для методов расширения очень удобно, например System.Enum, вы можете сделать что-то вроде ниже...

[Flags]
public enum ErrorTypes : int {
    None = 0,
    MissingPassword = 1,
    MissingUsername = 2,
    PasswordIncorrect = 4
}

public static class EnumExtensions {

    public static T Append<T> (this System.Enum type, T value) where T : struct
    {
        return (T)(ValueType)(((int)(ValueType) type | (int)(ValueType) value));
    }

    public static T Remove<T> (this System.Enum type, T value) where T : struct
    {
        return (T)(ValueType)(((int)(ValueType)type & ~(int)(ValueType)value));
    }

    public static bool Has<T> (this System.Enum type, T value) where T : struct
    {
        return (((int)(ValueType)type & (int)(ValueType)value) == (int)(ValueType)value);
    }

}

...

//used like the following...

ErrorTypes error = ErrorTypes.None;
error = error.Append(ErrorTypes.MissingUsername);
error = error.Append(ErrorTypes.MissingPassword);
error = error.Remove(ErrorTypes.MissingUsername);

//then you can check using other methods
if (error.Has(ErrorTypes.MissingUsername)) {
    ...
}

Это всего лишь пример, конечно - методы могли бы использовать немного больше работы...

Возможность иметь типы перечисления имеет значения, отличные от int (по умолчанию)

public enum MyEnum : long
{
    Val1 = 1,
    Val2 = 2
}

Кроме того, тот факт, что вы можете назначить любое числовое значение для этого перечисления:

MyEnum e = (MyEnum)123;

RealProxy позволяет создавать собственные прокси-серверы для существующих типов.

Это супер-продвинутый, и я не видел, чтобы кто-то еще использовал его, что может означать, что он также действительно не так полезен для большинства людей, но это одна из тех вещей, которые хорошо знать.

В принципе класс .NET RealProxy позволяет создавать так называемый прозрачный прокси для другого типа. Прозрачный в этом случае означает, что он выглядит полностью как прокси-целевой объект для своего клиента - но это действительно не так: это экземпляр вашего класса, который получен из RealProxy.

Это позволяет применять мощные и всесторонние услуги перехвата и "посредничества" между клиентом и любыми методами или свойствами, вызываемыми на реальном целевом объекте. Соедините эту мощь с шаблоном factory (IoC и т.д.), И вы можете передавать прозрачные прокси вместо реальных объектов, позволяя вам перехватывать все вызовы реальным объектам и выполнять действия до и после каждого вызова метода. На самом деле, я считаю, что это самая функциональность .NET для удаленного доступа к доменам приложений, процессов и машин:.NET перехватывает весь доступ, отправляет сериализованную информацию удаленному объекту, получает ответ и возвращает его вашему коду.

Может быть, пример даст понять, как это может быть полезно: я создал стоп ссылочной службы для моего последнего задания в качестве архитектора предприятия, который специфицировал стандартную внутреннюю композицию ( "стек" ) любых новых служб WCF в подразделении. Модель утверждала, что уровень доступа к данным для (скажем) службы Foo service IDAL<Foo>: создает Foo, читает Foo, обновляет Foo, удаляет Foo. Сервисные разработчики использовали предоставленный общий код (от меня), который мог бы найти и загрузить требуемый DAL для службы:

IDAL<T> GetDAL<T>(); // retrieve data access layer for entity T

Стратегии доступа к данным в этой компании часто были, но, с точки зрения производительности. Как архитектор, я не мог следить за каждым разработчиком сервиса, чтобы убедиться, что он написал уровень доступа к данным. Но то, что я мог сделать в шаблоне GetDAL factory, - это создать прозрачный прокси для запрошенного DAL (после того, как общий код модели службы, расположенный в DLL и загруженный), и использовать высокопроизводительные API-интерфейсы времени для профиля всех вызовов для любого метода DAL. Тогда ранжирование отставания - это просто вопрос сортировки таймингов DAL по убыванию общего времени. Преимущество этого для профилирования разработки (например, в среде IDE) заключается в том, что это можно сделать и в производственной среде, чтобы обеспечить SLA.

Вот пример тестового кода, который я написал для "профайлера сущностей", который был распространенным кодом для создания профилирующего прокси для любого типа с одной строкой:

[Test, Category("ProfileEntity")]
public void MyTest()
{
    // this is the object that we want profiled.
    // we would normally pass this around and call
    // methods on this instance.
    DALToBeProfiled dal = new DALToBeProfiled();

    // To profile, instead we obtain our proxy
    // and pass it around instead.
    DALToBeProfiled dalProxy = (DALToBeProfiled)EntityProfiler.Instance(dal);

    // or...
    DALToBeProfiled dalProxy2 = EntityProfiler<DALToBeProfiled>.Instance(dal);

    // Now use proxy wherever we would have used the original...
    // All methods' timings are automatically recorded
    // with a high-resolution timer
    DoStuffToThisObject(dalProxy);

    // Output profiling results
    ProfileManager.Instance.ToConsole();
}

Опять же, это позволяет перехватывать все методы и свойства, вызываемые клиентом на целевом объекте! В вашем производном от RealProxy классе вы должны переопределить Invoke:

[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
[SecurityPermission(SecurityAction.LinkDemand, 
    Flags = SecurityPermissionFlag.Infrastructure)] // per FxCop
public override IMessage Invoke(IMessage msg)
{
    IMethodCallMessage msgMethodCall = msg as IMethodCallMessage;
    Debug.Assert(msgMethodCall != null); // should not be null - research Invoke if this trips. KWB 2009.05.28

    // The MethodCallMessageWrapper
    // provides read/write access to the method 
    // call arguments. 
    MethodCallMessageWrapper mc =
        new MethodCallMessageWrapper(msgMethodCall);

    // This is the reflected method base of the called method. 
    MethodInfo mi = (MethodInfo)mc.MethodBase;

    IMessage retval = null;

    // Pass the call to the method and get our return value
    string profileName = ProfileClassName + "." + mi.Name;

    using (ProfileManager.Start(profileName))
    {
        IMessage myReturnMessage =
           RemotingServices.ExecuteMessage(_target, msgMethodCall);

        retval = myReturnMessage;
    }

    return retval;
}

Разве это не увлекательно, что может сделать .NET? Единственное ограничение состоит в том, что целевой тип должен быть получен из MarshalByRefObject. Надеюсь, это кому-то поможет.

Произвольные вложенные области {}

1. Для более точного определения области видимости

{ внутри элементов }, {, используя только фигурные скобки }, { > без инструкции управления }.

void MyWritingMethod() {

    int sameAge = 35;


    { // scope some work
        string name = "Joe";
        Log.Write(name + sameAge.ToString());
    }


    { // scope some other work
        string name = "Susan";
        Log.Write(name + sameAge.ToString());
    }

    // I'll never mix up Joe and Susan again
}

Внутри больших, запутанных или архаичных членов (не то, чтобы они когда-либо существовали), это помогает мне предотвратить использование неправильных имен переменных. Сфера применения до более тонких уровней.

2. Для улучшения кода или визуальной семантики

Например, этот код записи XML следует за уровнем отступов фактического генерируемого XML (то есть Visual Studio будет отступать от фигурных скобок)

XmlWriter xw = new XmlWriter(..);

//<root>
xw.WriteStartElement("root");
{
    //<game>
    xw.WriteStartElement("game");
    {
        //<score>#</score>
        for (int i = 0; i < scores.Length; ++i) // multiple scores
            xw.WriteElementString("score", scores[i].ToString());

    }
    //</game>
    xw.WriteEndElement();
}
//</root>
xw.WriteEndElement();

3. Mimic a 'with' statement

(Еще одно использование, чтобы сохранить временную работу из основной области)
Предоставлено Patrik: иногда используется для имитации VB-с-выражением на С#.

var somePerson = this.GetPerson();  // whatever 
{ 
    var p = somePerson; 
    p.FirstName = "John"; 
    p.LastName = "Doe"; 
    //... 
    p.City = "Gotham"; 
} 

Для проницательного программиста.

Я только что узнал об этом сегодня - и я работаю с С# в течение 5 лет!

Это идентификатор псевдонима пространства имен:

extern alias YourAliasHere;

Вы можете использовать его для загрузки нескольких версий того же типа. Это может быть полезно в сценариях обслуживания или обновления, где у вас есть обновленная версия вашего типа, которая не будет работать в каком-то старом коде, но вам нужно обновить ее до новой версии. Slap на спецификаторе псевдонима пространства имен, и компилятор позволит вам иметь оба типа в вашем коде.

Не скрыт, но я думаю, что многие разработчики не используют свойства HasValue и Value для типов с нулевым значением.

        int? x = null;
        int y;
        if (x.HasValue)
            y = x.Value;

Моим любимым является

global::

ключевое слово, чтобы избежать пространства имен с некоторыми нашими сторонними поставщиками кода...

Пример:

global::System.Collections.Generic.List<global::System.String> myList =
    new global::System.Collections.Generic.List<global::System.String>();

определение типов

Кто-то опубликовал, что они пропускают typedefs, но вы можете сделать это, как это

using ListOfDictionary = System.Collections.Generic.List<System.Collections.Generic.Dictionary<string, string>>;

и объявите его как

ListOfDictionary list = new ListOfDictionary();

Я прочитал все семь страниц, и я пропустил их:

string.join

Я видел много циклов for-loops для преобразования списка элементов в строку с разделителями. Это всегда боль, чтобы убедиться, что вы не начинаете с разделителя и не заканчиваете разделителем. Встроенный метод упрощает:

String.Join(",", new String[] { "a", "b", "c"});

TODO в комментарии

На самом деле это не функция С#, а больше возможностей Visual Studio. Когда вы начинаете свой комментарий с TODO, он добавляется в список задач Visual Studio (View → Список задач. Комментарии)

// TODO: Implement this!
throw new NotImplementedException();

Методы расширения соответствуют Generics

Вы можете комбинировать методы расширения с Generics, когда вы думаете о подсказке ранее в этом разделе, вы можете добавлять расширения к определенным интерфейсам

public static void Process<T>(this T item) where T:ITest,ITest2 {}

Enumerable.Range

Просто хотите список целых чисел?

Enumerable.Range(0, 15)

Я попытаюсь придумать еще...

Ширина в string.Format()

Console.WriteLine("Product: {0,-7} Price: {1,5}", product1, price1);
Console.WriteLine("Product: {0,-7} Price: {1,5}", product2, price2);

производит

from Блог Prabir | Скрытая функция С#

Вы можете "использовать" несколько объектов в одном операторе using.

using (Font f1= new Font("Arial", 10.0f), f2 = new Font("Arial", 10.0f))
{
    // Use f1 and f2.
}

Обратите внимание, что уже есть ответ, в котором говорится, что вы можете сделать это:

using (Font f1= new Font("Arial", 10.0f))
using (Font f2 = new Font("Arial", 10.0f))
{    }

Что отличает меня.

Мне нравится ключевое слово continue.

Если вы нажмете условие в цикле и не хотите ничего делать, но продвигайте цикл, просто вставьте "продолжить".

например:.

foreach(object o in ACollection)
{
  if(NotInterested)
     continue;
}

Инициализация поля по требованию в одной строке:

public StringBuilder Builder
{
    get { return _builder ?? (_builder = new StringBuilder()); }
}

Я не уверен, что я чувствую, что С# поддерживает выражения присваивания, но эй, это там: -)

Полный доступ к стеку вызовов:

public static void Main()
{
  StackTrace stackTrace = new StackTrace();           // get call stack
  StackFrame[] stackFrames = stackTrace.GetFrames();  // get method calls (frames)

  // write call stack method names
  foreach (StackFrame stackFrame in stackFrames)
  {
    Console.WriteLine(stackFrame.GetMethod().Name);   // write method name
  }
}

Итак, если вы возьмете первый, вы знаете, в какой функции вы находитесь. Если вы создаете вспомогательную функцию трассировки - возьмите ее до последней, вы узнаете своего вызывающего.

@lomaxx Я также узнал, что на днях (в то же время я узнал ваш совет), что теперь вы можете иметь разрозненные уровни доступа по одному и тому же свойству:

public string Name { get; private set;}

Таким образом, только сам класс может установить свойство Name.

public MyClass(string name) { Name = name; }

JavaScript-подобные анонимные встроенные функции

Возврат строки:

var s = new Func<String>(() =>
{
    return "Hello World!";
})();

Возвращает более сложный объект:

var d = new Func<Dictionary<Int32, String>>(() =>
{
    return new Dictionary<Int32, String>
    {
        { 0, "Foo" },
        { 1, "Bar" },
        { 2, "..." }
    };
})();

Практический пример:

var tr = new TableRow();

tr.Cells.AddRange
(
    new[]
    {
        new TableCell { Text = "" },
        new TableCell { Text = "" },
        new TableCell { Text = "" },

        new TableCell
        {
            Text = new Func<String>(() =>
            {
                return @"Result of a chunk of logic, without having to define
                         the logic outside of the TableCell constructor";
            })()
        },

        new TableCell { Text = "" },
        new TableCell { Text = "" }
    }
);

Примечание. Вы не можете повторно использовать имена переменных внутри области встроенной функции.

Альтернативный синтаксис

// The one-liner
Func<Int32, Int32, String> Add = (a, b) => Convert.ToString(a + b);

// Multiple lines
Func<Int32, Int32, String> Add = (a, b) =>
{
    var i = a + b;

    return i.ToString();
};

// Without parameters
Func<String> Foo = () => "";

// Without parameters, multiple lines
Func<String> Foo = () =>
{
    return "";
};

Сократите строку и добавьте горизонтальный эллипс...

Func<String, String> Shorten = s => s.Length > 100 ? s.Substring(0, 100) + "&hellip;" : s;

Программисты, перемещающиеся с C/С++, могут пропустить это:

В С#% (оператор модуля) работает над поплавками!

Свойство Environment.UserInteractive.

Отчеты свойств UserInteractive false для процесса Windows или службы, такой как IIS, которая работает без пользовательский интерфейс. Если это свойство false, не отображать модальные диалоги или сообщений, потому что нет графический пользовательский интерфейс для пользователя для взаимодействия с.

Вложение с помощью выражений

Обычно мы делаем это следующим образом:

StringBuilder sb = new StringBuilder();
using (StringWriter sw = new StringWriter()) {
    using (IndentedTextWriter itw = new IndentedTextWriter(sw)) {
        ... 
    }
}

Но мы можем сделать это следующим образом:

StringBuilder sb = new StringBuilder();
using (StringWriter sw = new StringWriter())
using (IndentedTextWriter itw = new IndentedTextWriter(sw)) {
    ... 
}

Также существует атрибут ThreadStaticAttribute, чтобы сделать статическое поле уникальным для потока, поэтому вы можете иметь строго типизированное локальное хранилище потоков.

Даже если методы расширения не являются такими секретными (LINQ основан на них), это может быть не так очевидно, насколько полезными и читаемыми они могут быть для вспомогательных методов:

//for adding multiple elements to a collection that doesn't have AddRange
//e.g., collection.Add(item1, item2, itemN);
static void Add<T>(this ICollection<T> coll, params T[] items)
 { foreach (var item in items) coll.Add(item);
 }

//like string.Format() but with custom string representation of arguments
//e.g., "{0} {1} {2}".Format<Custom>(c=>c.Name,"string",new object(),new Custom())
//      result: "string {System.Object} Custom1Name"
static string Format<T>(this string format, Func<T,object> select, params object[] args)
 { for(int i=0; i < args.Length; ++i)
    { var x = args[i] as T;
      if (x != null) args[i] = select(x);
    }
   return string.Format(format, args);
 }

Два моих личных фаворита, которые я вижу редко:

• Фрагменты (особенно для свойств, которые были улучшены для Visual Studio 2008)
• ObsoleteAttribute

Легко определить тип, с которым была объявлена ​​ переменная (из мой ответ):

using System;
using System.Collections.Generic;

static class Program
{
    public static Type GetDeclaredType<T>(T x)
    {
        return typeof(T);
    }

    // Demonstrate how GetDeclaredType works
    static void Main(string[] args)
    {
        IList<string> iList = new List<string>();
        List<string> list = null;

        Console.WriteLine(GetDeclaredType(iList).Name);
        Console.WriteLine(GetDeclaredType(list).Name);
    }
}

Результаты:

IList`1
List`1

И его имя (заимствовано из "Получить имя переменной" ):

static void Main(string[] args)
{
    Console.WriteLine("Name is '{0}'", GetName(new {args}));
    Console.ReadLine();
}

static string GetName<T>(T item) where T : class
{
    var properties = typeof(T).GetProperties();
    return properties[0].Name;
}

Результат: Name is 'args'

С#?? нулевой коалесцирующий оператор -

Не очень скрытый, но редко используемый. Наверное, потому что многие разработчики пробегают милю, когда видят условное? оператора, поэтому они запускают два, когда видят это. Используется:

string mystring = foo ?? "foo was null"

а не

string mystring;
if (foo==null)
    mystring = "foo was null";
else
    mystring = foo;

На самом деле это не скрытая функция С#, но я недавно обнаружил класс WeakReference и был потрясен им (хотя это может быть предвзято благодаря тому, что это помогло мне найти решение конкретной проблемы моего...)

AppDomain.UnhandledException Event также является кандидатом на скрытие.

Это событие предоставляет уведомление о неперехваченных исключениях. Он позволяет приложению регистрировать информацию об исключении, прежде чем системный обработчик по умолчанию сообщает об исключении пользователю и завершает работу приложения. Если имеется достаточная информация о состоянии приложения, могут быть предприняты другие действия - например, сохранение данных программы для последующего восстановления. Предупреждение рекомендуется, так как данные программы могут быть повреждены, если исключения не обрабатываются.

Мы видим, что даже на этом сайте многие люди задаются вопросом, почему их приложение не запускается, почему оно разбилось и т.д. Событие AppDomain.UnhandledException может быть очень полезно для таких случаев, поскольку оно обеспечивает возможность по крайней мере для регистрации причины сбоя приложения.

В С# есть некоторые действительно скрытые ключевые слова и функции, связанные с недокументированным классом TypedReference. Следующие недопустимые ключевые слова:

• __makeref
• __reftype
• __refvalue
• __arglist

Примеры использования:

// Create a typed reference
int i = 1;
TypedReference tr1 = __makeref(i);
// Get the type of a typed reference
Type t = __reftype(tr1);
// Get the value of a typed referece
int j = __refvalue(tr1, int); 
// Create a method that accepts and arbitrary number of typed references
void SomeMethod(__arglist) { ...
// Call the method
int x = 1;
string y = "Foo";
Object o = new Object();
SomeMethod(__arglist(x,y,o));
// And finally iterate over method parameters
void SomeMethod(__arglist) {
    ArgIterator ai = new ArgIterator(__arglist);
while(ai.GetRemainingCount() >0)
{
      TypedReference tr = ai.GetNextArg();
      Console.WriteLine(TypedReference.ToObject(tr));
}}

true и false Операторы действительно странные.

Более полный пример можно найти здесь.

Изменить: есть связанный вопрос SO Что такое фальшивый оператор в С# для?

Директива предпроцессора #if DEBUG. Это полезно для тестирования и отладки (хотя я обычно предпочитаю единичный тестовый маршрут).

string customerName = null;
#if DEBUG
  customerName = "Bob"
#endif

Он выполнит только код, если для Visual Studio установлено значение скомпилируйте в режиме "Отладка". В противном случае блок кода будет игнорируется компилятором (и неактивен в Visual Studio).

Я не нашел никого, кто использует string.Join, чтобы присоединиться к строкам с помощью разделителя. Каждый пишет о том же уродливом for-loop

var sb = new StringBuilder();
var count = list.Count();
for(int i = 0; i < count; i++)
{
  if (sb.Length > 0) sb.Append(seperator);
  sb.Append(list[i]);
}

return sb.ToString();

вместо

return string.Join(separator, list.ToArray());

Я обнаружил, что об этой функции знают лишь немногие разработчики.

Если вам нужен метод, который работает с переменной value-type через некоторый интерфейс (реализованный этим типом значений), легко избежать бокса во время вызова метода.

Пример кода:

using System;
using System.Collections;

interface IFoo {
    void Foo();
}
struct MyStructure : IFoo {
    public void Foo() {
    }
}
public static class Program {
    static void MethodDoesNotBoxArguments<T>(T t) where T : IFoo {
        t.Foo();
    }
    static void Main(string[] args) {
        MyStructure s = new MyStructure();
        MethodThatDoesNotBoxArguments(s);
    }
}

Код IL не содержит никаких инструкций в поле:

.method private hidebysig static void  MethodDoesNotBoxArguments<(IFoo) T>(!!T t) cil managed
{
  // Code size       14 (0xe)
  .maxstack  8
  IL_0000:  ldarga.s   t
  IL_0002:  constrained. !!T
  IL_0008:  callvirt   instance void IFoo::Foo()
  IL_000d:  ret
} // end of method Program::MethodDoesNotBoxArguments

.method private hidebysig static void  Main(string[] args) cil managed
{
  .entrypoint
  // Code size       15 (0xf)
  .maxstack  1
  .locals init ([0] valuetype MyStructure s)
  IL_0000:  ldloca.s   s
  IL_0002:  initobj    MyStructure
  IL_0008:  ldloc.0
  IL_0009:  call       void Program::MethodDoesNotBoxArguments<valuetype MyStructure>(!!0)
  IL_000e:  ret
} // end of method Program::Main

См. Richter, J. CLR через С#, 2-е издание, глава 14: Интерфейсы, раздел Об общих и интерфейсных ограничениях.

См. также мой ответ на другой вопрос.

Частичные методы

Чарли Калверт объясняет частичные методы в своем блоге

У Скотта Кейта есть приятная демонстрация частичного метода здесь

• Точки расширяемости в Code Generated class (LINQ to SQL, EF)
• Не компилируется в dll, если он не реализован (проверьте его с помощью .NET Reflector)

На основании того, что этот поток должен иметь право "вещи, о которых вы не знали о С# до недавнего времени, несмотря на то, что вы уже все знали", моя личная функция - асинхронные делегаты.

До тех пор, пока я не прочитаю книгу Джеффа Рихтера С#/CLR (отличная книга, все, кто должен ее читать .NET) Я не знал, что вы можете назвать любого делегата, используя BeginInvoke/EndInvoke. Я обычно делаю много вызовов ThreadPool.QueueUserWorkItem (что, как мне кажется, очень похоже на то, что делает делегат BeginInvoke), но добавление стандартизованного шаблона join/rendezvous иногда может быть действительно полезным.

ОК, это может показаться очевидным, но я хочу упомянуть метод Object.Equals (статический, с двумя аргументами).

Я уверен, что многие люди даже не знают об этом или забывают об этом, но в некоторых случаях это может действительно помочь. Например, если вы хотите сравнить два объекта для равенства, не зная, являются ли они нулевыми. Сколько раз вы писали что-то вроде этого:

if ((x == y) || ((x != null && y != null) && x.Equals(y)))
{
    ...
}

Когда вы можете просто написать:

if (Object.Equals(x, y))
{
    ...
}

(Object.Equals фактически реализуется точно так же, как в первом примере кода)

Как насчет IObservable?

Практически все знают IEnumerable, но их математическое двойное кажется неизвестным IObservable. Может быть, потому, что его новый в .NET 4.

Что он делает, вместо того, чтобы извлекать информацию (например, перечислимую), она передает информацию подписчику (наблюдателям).

Вместе с расширения Rx он изменит, как мы имеем дело с событиями. Чтобы проиллюстрировать, насколько мощным является проверка очень короткого примера здесь.

Цели атаки

Каждый видел его. В основном, когда вы видите это:

[assembly: ComVisible(false)]

Часть "assembly:" этого атрибута является целевой. В этом случае атрибут применяется к сборке, но есть и другие:

[return: SomeAttr]
int Method3() { return 0; } 

В этом примере атрибут применяется к возвращаемому значению.

Один класс, который мне нравится, это System.Xml.XmlConvert, который можно использовать для чтения значений из тега xml. Особенно, если я читаю логическое значение из атрибута xml или элемента, я использую

bool myFlag  = System.Xml.XmlConvert.ToBoolean(myAttribute.Value);

Примечание: поскольку логический тип в xml принимает 1 и 0 в дополнение к "true" и "false" в качестве допустимых значений, использование сравнения строк в этом случае подвержено ошибкам.

Несколько человек упомянули использование блоков, но я думаю, что они намного полезнее, чем люди поняли. Подумайте о них как об инструменте AOP бедного человека. У меня есть множество простых объектов, которые фиксируют состояние в конструкторе, а затем восстанавливают его в методе Dispose(). Это позволяет мне обернуть часть функциональности в используемом блоке и убедиться, что состояние будет восстановлено в конце. Например:

using(new CursorState(this, BusyCursor));
{
    // Do stuff
}

CursorState фиксирует текущий курсор, используемый формой, затем устанавливает форму для использования курсора. В конце он восстанавливает исходный курсор. Я делаю такие вещи, например, захватывая выбор и текущую строку на сетке перед обновлением и т.д.

Я опаздываю на эту вечеринку, поэтому мои первые выборы уже приняты. Но я не видел, чтобы кто-нибудь упоминал об этом камне: