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

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

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

Decimal = M
Float = F
Double = D

// for example
double d = 30D;

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

Long = L
Unsigned Long = UL
Unsigned Int = U

Вот полезный для регулярных выражений и путей к файлам:

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

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

1. ?? - объединение использования оператора
2. ( директива оператора / ) - большое ключевое слово, которое может использоваться для больше, чем просто вызова, Располагает
3. только для чтения - должен использоваться больше
4. netmodules - слишком плохо в Visual Studio

лямбда-выражения

Func<int, int, int> add = (a, b) => (a + b);

неясные форматы строки

Console.WriteLine("{0:D10}", 2); // 0000000002

Dictionary<string, string> dict = new Dictionary<string, string> { 
    {"David", "C#"}, 
    {"Johann", "Perl"}, 
    {"Morgan", "Python"}
};

Console.WriteLine( "{0,10} {1, 10}", "Programmer", "Language" );

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

foreach (string key in dict.Keys)
{
    Console.WriteLine( "{0, 10} {1, 10}", key, dict[key] );             
}

Я не начинал действительно ценить блоки "использования" до недавнего времени. Они делают вещи настолько более опрятными:)

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

[AttributeUsage( AttributeTargets.ReturnValue )]
public class CuriosityAttribute:Attribute
{
}

public class Bar
{
    [return: Curiosity]
    public Bar ReturnANewBar()
    {
        return new Bar();
    }
}

Это было действительно скрытой функцией меня:-)

Маркировка моего endregions...

#region stuff1
 #region stuff1a
 //...
 #endregion stuff1a
#endregion stuff1

Как насчет использования этого:

#if DEBUG
            Console.Write("Debugging");
#else
            Console.Write("Final");
#endif

Когда ваше решение скомпилировано с опцией DEBUG, оно выведет «Отладка».

Если ваш компилятор установлен в Release, он напишет «Final».

Объединения (вид общей памяти 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

просто добавляют Систему использования. Время выполнения. InteropServices;

Я давно не знал ключевое слово «как».

MyClass myObject = (MyClass) obj;

против

MyClass myObject = obj as MyClass;

Секунда вернет ноль, если obj не является MyClass, а не сгенерирует исключение приведения класса.

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

public string Name { get; private set;}

Тот путь только сам класс может установить свойство Name.

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

Для вызова конструктора базового класса просто помещенной основой () встраивают с конструктором.
Для вызова метода базового класса можно просто поместить основу. MethodName () в методе производного класса

class ClassA 
{
  public ClassA(int a)
  {
    //Do something
  }

  public void Method1()
  {
     //Do Something
  }
}

class ClassB : ClassA
{
  public ClassB(int a) : base(a) // calling the base class constructor
  {
    //Do something
  }

  public void Method2()
  {
    base.Method1();               // calling the base class method
  }
}

, Конечно, можно назвать методы базового класса, просто говоря base.MethodName()

Если Вы хотите выйти из своей программы, не называя никого наконец блоками или использованием финализаторов FailFast:

Environment.FailFast()

Синтаксис делегата развился по последовательным версиям C#, но я все еще нахожу их трудными помнить. К счастью, Action<> и Func<> делегатов легко помнить.

, Например:

• Action<int> метод делегата, который берет единственный международный аргумент и возвращается пусто.
• Func<int> метод делегата, который не берет аргументов и возвращается, интервал
• Func<int, bool> является методом делегата, который берет единственный международный аргумент и возвращает bool.

Эти функции были представлены в версии 3.5 платформы.NET.

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

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

, Если Вы собираетесь использовать '', почему развивают его с безопасным броском, использующим 'как'? Если Вы установили, что obj является действительно MyClass, стандартный трясиной состав исполнителей:

c = (MyClass)obj

... никогда не собирается перестать работать.

Точно так же Вы могли просто сказать:

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

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

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

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

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

Как насчет FlagsAttribute на перечислении? Это позволяет, Вы для выполнения битовых операций... взяли меня навсегда, чтобы узнать, как сделать битовые операции в.NET приятно.

Мне нравится искать материал в like:-

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

списка Скорее, than:-

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

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

ConditionalAttribute

Позволяет указать компилятору пропустить вызов метода, отмеченного атрибутом при определенных условиях (#define).

Тот факт, что вызов метода опущен, также означает, что его параметры не оцениваются. Это очень удобно, и это то, что позволяет вам вызывать дорогостоящие функции проверки в Debug.Assert () и не беспокоиться о том, что они замедляют сборку релиза.

Двумя вещами, которые я люблю, являются свойства Automatic, таким образом, можно свернуть код вниз еще больше:

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

Два из моих любимых, которые я редко вижу используемый:

1. Отрывки (особенно для свойств, который был сделан еще лучше для Visual Studio 2008)
2. ObsoleteAttribute

От Rick Strahl :

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

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

Вы можете изменить схему округления, используя:

var value = -0.5;
var value2 = 0.5;
var value3 = 1.4;

Console.WriteLine( Math.Round(value, MidpointRounding.AwayFromZero) ); //out: -1
Console.WriteLine(Math.Round(value2, MidpointRounding.AwayFromZero)); //out: 1
Console.WriteLine(Math.Round(value3, MidpointRounding.ToEven)); //out: 1

Я часто сталкивался с потребностью сохранить универсальный объект параметра в состояние отображения в базовом классе.

public abstract class BaseListControl<ListType,KeyType,ParameterType>
                 : UserControl 
                 where ListType : BaseListType
                 && ParameterType : BaseParameterType, new
{

    private const string viewStateFilterKey = "FilterKey";

    protected ParameterType Filters
    {
        get
        {
            if (ViewState[viewStateFilterKey] == null)
                ViewState[viewStateFilterKey]= new ParameterType();

            return ViewState[viewStateFilterKey] as ParameterType;
        }
        set
        {
            ViewState[viewStateFilterKey] = value;
        }
    }

}

Использование:

private void SomeEventHappened(object sender, EventArgs e)
{
    Filters.SomeValue = SomeControl.SelectedValue;
}

private void TimeToFetchSomeData()
{
    GridView.DataSource = Repository.GetList(Filters);
}

Этот небольшой прием с, "где ParameterType: BaseParameterType, новый", то, что заставляет его действительно работать.

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

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

Что-то я отсутствовал в течение долгого времени: можно сравнить строки с

"string".equals("String", StringComparison.InvariantCultureIgnoreCase)

вместо выполнения:

"string".ToLower() == "String".ToLower();

Мне нравится тот факт, что я могу использовать LINQ для объектов в старой версии .NET 2.0 (т. Е. Не требовать повсеместной установки .NET 3.5). Все, что вам нужно, это реализация всех методов расширения оператора запроса - см. LINQBridge

Возможность использовать выражения LINQ для выполнения строго типизированного отражения:

static void Main(string[] args)
{
  var domain = "matrix";
  Check(() => domain);
  Console.ReadLine();
}

static void Check<T>(Expression<Func<T>> expr)
{
  var body = ((MemberExpression)expr.Body);
  Console.WriteLine("Name is: {0}", body.Member.Name);
  Console.WriteLine("Value is: {0}", ((FieldInfo)body.Member)
   .GetValue(((ConstantExpression)body.Expression).Value));
}

// output:
// Name is: 'domain'
// Value is: 'matrix'

Более подробная информация доступна на Как узнать имя переменной или параметра в C #?

Оператор присваивания Or довольно хорош. Вы можете написать это:

x |= y

вместо этого:

x = x | y

Это часто бывает практичным, если вам нужна переменная или свойство (x в примере), которое начинается как false, но вы хотите изменить его на значение какой-либо другой логической переменной / свойства , только если это другое значение равно true.

Падение через switch - case можно достичь, не имея кода в case (см. case 0), или используя специальные goto case (см. case 1) или goto default ( см. case 2) формы:

switch (/*...*/) {
    case 0: // shares the exact same code as case 1
    case 1:
        // do something
        goto case 2;
    case 2:
        // do something else
        goto default;
    default:
        // do something entirely different
        break;
}

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