Скрытые возможности C #? [закрыто]

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

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

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

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

Foreach использует Утку, Вводящую

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

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

• Ваш объект обеспечивает открытый метод GetEnumerator , который
  • не берет параметров
  • , возвращают тип, который имеет двух участников
    1. без параметров метод MoveNext что возвраты булевская переменная
    2. свойство Current с методом get что возвраты Объект

, Например,

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's da man!");
}

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

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

Вложение Используя Операторы

Обычно мы делаем это как это:

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)) {
    ... 
}

Мне нравится ключевое слово , продолжаются .

, Если Вы поражаете условие в цикле и не хотите делать что-нибудь кроме усовершенствования, цикл просто всовывает, "продолжаются";.

, Например:

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

Мой фаворит

global::

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

Пример:

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

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

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

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

Я забрал этого при использовании 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);

См." Неявное Преобразование Группы Метода в C#" для больше.

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

Атрибуты в целом, но больше всего DebuggerDisplay. Сохраняет Вас годы.

Пара других атрибутов от Система. Диагностика пространство имен довольно полезна.

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

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

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

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

, Если Вы имеете

string s = @"cat
             dog
             fish"

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

cat
             dog
             fish

Ключевое слово 'по умолчанию' в универсальных типах:

T t = default(T);

результаты в 'пустом указателе', если T является ссылочным типом, и 0, если это - интервал, ложь, если это - булевская переменная и так далее.

Я склонен находить, что большинство разработчиков C# не знает о 'nullable' типах. В основном, примитивы, которые могут иметь нулевое значение.

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

Набор nullable двойное, num1, к пустому указателю, затем установил двойного постоянного клиента, num2, к num1 или -100 , если num1 был пустым.

http://msdn.microsoft.com/en-us/library/1t3y8s4s (По сравнению с 80) .aspx

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

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

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

Все остальное, плюс

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) свойства Auto могут иметь различные объемы:

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

Способность иметь перечислимые типы имеет значения кроме интервала (значение по умолчанию)

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

кроме того, то, что можно присвоить любое числовое значение тому перечислению:

MyEnum e = (MyEnum)123;

Использование @ для имен переменных, которые являются ключевыми словами.

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

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

__makeref

__reftype

__refvalue

__arglist

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

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

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

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

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

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

становится

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

Возможно, не усовершенствованная техника, но один я вижу все время, что это сводит меня с ума:

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

может быть сжат к:

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

При попытке использовать фигурные скобки в Строке. Выражение формата...

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"

Просто изученные, анонимные типы могут вывести имена свойства из имени переменной:

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

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

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

extern alias YourAliasHere;

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

Environment.NewLine

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

Стараются не проверять на пустые обработчики событий

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

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

Позволяют Вам сделать это

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

Вместо этого

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

, также посмотрите этот связанное обсуждение и этот сообщение в блоге Eric Lippert по этой теме (и возможные оборотные стороны).

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

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

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

Правда, Ложь, FileNotFound?