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

В C #% (оператор модуля) работает с числами с плавающей запятой!

Анонимные встроенные функции, подобные 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;

Вы можете «использовать» несколько объектов в одном операторе 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))
{    }

Это отличается от моего.

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

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

Результат: Имя - 'args'

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

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

Пример кода:

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

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

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

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

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

производит

из Prabir's Blog | Скрытая возможность C#

typedefs

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

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

и объявить это как

ListOfDictionary list = new ListOfDictionary();

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

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

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

Мой любимый атрибут: InternalsVisibleTo

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

Вставьте это в файл AssemblyInfo.cs или аналогичный, и ваша тестовая сборка получит полный доступ ко всем внутренним компонентам, требующим тестирования.

[assembly: InternalsVisibleTo("MyLibrary.Test, PublicKey=0024...5c042cb")]

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

Доступно в .Net Framework 2.0+, Compact Framework 2.0+ и XNA Framework 1.0+.

Вы можете добавлять и удалять делегатов с меньшим набором текста.

Обычный способ:

handler += new EventHandler(func);

Меньше набора текста:

handler += func;

При определении настраиваемых атрибутов вы можете использовать их с [MyAttAttribute] или с [MyAtt]. Когда классы существуют для обеих записей, возникает ошибка компиляции.

Для их различения можно использовать специальный символ @:

[AttributeUsage(AttributeTargets.All)]
public class X: Attribute
{}

[AttributeUsage(AttributeTargets.All)]
public class XAttribute: Attribute
{}

[X]      // Error: ambiguity
class Class1 {}

[XAttribute]   // Refers to XAttribute
class Class2 {}

[@X]      // Refers to X
class Class3 {}

[@XAttribute]   // Refers to XAttribute
class Class4 {}

Вы можете ограничить срок службы и, следовательно, объем переменных, используя квадратные скобки {} .

{
    string test2 = "3";
    Console.Write(test2);
}

Console.Write(test2); //compile error

test2 живет только в квадратных скобках.

Использование оператора "~" с FlagAttribute и enum
Иногда мы будем использовать атрибут Flag с перечислением для выполнения побитовых манипуляций с перечислением.

 [Flags]
 public enum Colors
 {
    None  = 0,
    Red   = 1,
    Blue  = 2,
    White = 4,
    Black = 8,
    Green = 16,
    All   = 31 //It seems pretty bad...
 }

Обратите внимание, что, значение опциона «Все», которое в enum довольно странное.
Вместо этого мы можем использовать оператор "~" с помеченным enum.

 [Flags]
 public enum Colors
 {
    None  = 0,
    Red   = 1,
    Blue  = 2,
    White = 4,
    Black = 8,
    Green = 16,
    All   = ~0 //much better now. that mean 0xffffffff in default.
 }

А как насчет IObservable ?

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

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

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

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

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

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

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

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

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

Еще одно замечание по обработчикам событий: вы можете просто создать метод расширения повышения, например так:

public static class EventExtensions {
    public static void Raise<T>(this EventHandler<T> @event, 
                                object sender, T args) where T : EventArgs {
        if(@event!= null) {
            @event(sender, args);
        }
    }
}

Затем вы можете использовать его для создания событий:

public class MyImportantThing {
    public event EventHandler<MyImportantEventEventArgs> SomethingHappens;
    ...
    public void Bleh() {
        SomethingHappens.Raise(this, new MyImportantEventEventArgs { X=true });
    }
}

Этот метод имеет дополнительное преимущество, заключающееся в том, что стандарт кодирования (с использованием EventHandler <> ).

Нет смысла писать одну и ту же функцию снова и снова. Возможно, следующая версия C #, наконец, будет иметь InlineAttribute , который можно будет поместить в метод расширения и заставит компилятор встроить определение метода (что сделает этот способ почти стандартным и самым быстрым).

edit: удалена временная переменная внутри метода расширения на основе комментариев

Не совсем скрытый, но полезный. Когда у вас есть перечисление с флагами, вы можете использовать shift-left, чтобы сделать все более понятным. Например,

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

fixed statement

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

Оператор fixed устанавливает указатель на управляемую переменную и "прикалывает" эту переменную во время выполнения оператора.

stackalloc

Оператор stackalloc выделяет блок памяти на стеке.

Мне нравится

#if DEBUG
           //Code run in debugging mode

#else
           //Code run in release mode

#endif

Работа с перечислениями.

Преобразуйте строку в Перечисление:

enum MyEnum
{
    FirstValue,
    SecondValue,
    ThirdValue
}

string enumValueString = "FirstValue";
MyEnum val = (MyEnum)Enum.Parse(typeof(MyEnum), enumValueString, true)

• Я использую это для загрузки значения CacheItemPriority в моих приложениях ASP.NET от таблицы настроек в базе данных так, чтобы я мог управлять кэшированием (наряду с другими настройками) динамично, не удаляя приложение.

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

MyEnum val = MyEnum.SecondValue;
if (val < MyEnum.ThirdValue)
{
    // Do something
}

Вот тот, который я недавно обнаружил, который был полезен:

Microsoft.VisualBasic.Logging.FileLogTraceListener

Ссылка MSDN

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

Это "скрыто" потому что в Microsoft. Блок VisualBasic..., но можно использовать его от C# также.

Использование ключевого слова по умолчанию в универсальном коде для возврата значения по умолчанию для типа.

public class GenericList<T>
{
    private class Node
    {
        //...

        public Node Next;
        public T Data;
    }

    private Node head;

    //...

    public T GetNext()
    {
        T temp = default(T);

        Node current = head;
        if (current != null)
        {
            temp = current.Data;
            current = current.Next;
        }
        return temp;
    }
}

Другой пример здесь

Я вполне наслаждаюсь неявными универсальными параметрами на функциях. Например, если Вы имеете:

public void DoStuff<T>(T value);

Вместо того, чтобы назвать его как это:

DoStuff<int>(5);

Вы можете:

DoStuff(5);

И это разработает универсальный тип от типа параметра.

• Это не работает при вызове метода посредством отражения.
• Я не забываю иметь некоторые странные проблемы на Моно.