Для получения полного доступа
зарегистрируйтесь


  public class PropertyStore
  {
      private readonly ConcurrentDictionary<string, object> _dictionary = new ConcurrentDictionary<string, object>();
      public T Get<T>(Func<T> instanceCreator, [CallerMemberName] string propertyName = "")
      {
          _dictionary.GetOrAdd(propertyName, key => instanceCreator());
          return (T)_dictionary[propertyName];
      }

      public void Set<T>(T value, [CallerMemberName] string propertyName = "")
      {
          _dictionary.Adate(propertyName, value, (key, oldValue) => value);
      }
  }

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

  public class MyClass
  {
      private readonly PropertyStore _store = new PropertyStore();

      public string MyString
      {
          get => _store.Get(() => "It's my default string");
          set => _store.Set(value);
      }

      public int MyInt
      {
          get => _store.Get(() => 5);
          set => _store.Set(value);
      }

      public SecondClass MySecondClass
      {
          get => _store.Get(() => new SecondClass());
          set => _store.Set(value);
      }
  }

Проверка:

  class Program
  {
      static void Main(string[] args)
      {
          var myClass = new MyClass();

          Console.WriteLine(myClass.MyString); //"It's my default string"
          myClass.MyString = "Custom string";
          Console.WriteLine(myClass.MyString); //Custom string

          Console.WriteLine(myClass.MyInt); //5
          myClass.MyInt = 10;
          Console.WriteLine(myClass.MyInt); //10

          Console.WriteLine(myClass.MySecondClass); //SecondClass Initialized
                                                    //SecondClass

          Console.WriteLine(myClass.MySecondClass); //SecondClass
      }
  }

  public class SecondClass
  {
      public SecondClass()
      {
          Console.WriteLine($"{nameof(SecondClass)} Initialized");
      }

      public override string ToString()
      {
          return nameof(SecondClass);
      }
  }
  public class PropertyStore
  {
      private readonly ConcurrentDictionary<string, object> _dictionary = new ConcurrentDictionary<string, object>();
      public T Get<T>(Func<T> instanceCreator, [CallerMemberName] string propertyName = "")
      {
          _dictionary.GetOrAdd(propertyName, key => instanceCreator());
          return (T)_dictionary[propertyName];
      }

      public void Set<T>(T value, [CallerMemberName] string propertyName = "")
      {
          _dictionary.AddOrUpdate(propertyName, value, (key, oldValue) => value);
      }
  }

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

  public class MyClass
  {
      private readonly PropertyStore _store = new PropertyStore();

      public string MyString
      {
          get => _store.Get(() => "It's my default string");
          set => _store.Set(value);
      }

      public int MyInt
      {
          get => _store.Get(() => 5);
          set => _store.Set(value);
      }

      public SecondClass MySecondClass
      {
          get => _store.Get(() => new SecondClass());
          set => _store.Set(value);
      }
  }

Проверка:

  class Program
  {
      static void Main(string[] args)
      {
          var myClass = new MyClass();

          Console.WriteLine(myClass.MyString); //"It's my default string"
          myClass.MyString = "Custom string";
          Console.WriteLine(myClass.MyString); //Custom string

          Console.WriteLine(myClass.MyInt); //5
          myClass.MyInt = 10;
          Console.WriteLine(myClass.MyInt); //10

          Console.WriteLine(myClass.MySecondClass); //SecondClass Initialized
                                                    //SecondClass

          Console.WriteLine(myClass.MySecondClass); //SecondClass
      }
  }

  public class SecondClass
  {
      public SecondClass()
      {
          Console.WriteLine($"{nameof(SecondClass)} Initialized");
      }

      public override string ToString()
      {
          return nameof(SecondClass);
      }
  }

Клиентская OAuth авторизация для Desktop приложений.

Использование: Создаем авторизатор к примеру для вк

public class VkAuthorizer : Authorizer
    {
        public VkAuthorizer(string clientId, IEnumerable<string> scopes)
            : base(new Uri("https://oauth.vk.com/authorize"), clientId, new Uri("https://oauth.vk.com/blank.html"), "page", scopes)
        {
        }
    }

Получаем токен

var authorizer = new VkAuthorizer("YOUR_VK_CLIENT_ID", new[] { "wall, group, pages, offline" });
var token = authorizer.AuthorizeAsync().Result;
public class BrowserForm : IDisposable
    {
        private readonly WebBrowser _browser;
        private readonly Form _form;

        public BrowserForm()
        {
            _form = new Form {Width = 1200, Height = 800}; //Переопределить под себя
            _browser = new WebBrowser {Parent = _form, Dock = DockStyle.Fill, ScriptErrorsSuppressed = false};
        }

        public void Dispose()
        {
        }

        public void Show()
        {
            _form.Show();
        }

        public void Navigate(string uriString)
        {
            _browser.Navigate(uriString);
        }

        public void Close()
        {
            _form.Close();
        }
    
        public event WebBrowserNavigatedEventHandler Navigated
        {
            add { _browser.Navigated += value; }
            remove { _browser.Navigated -= value; }
        }
    }

public abstract class Authorizer
    {
        private readonly string _clientId;
        private readonly Uri _redirectUri;
        private readonly Uri _oAuthBaseUri;
        private readonly string _dispaly;
        private readonly ILogger _logger;
        private readonly IEnumerable<string> _scopes;

        protected Authorizer(Uri oAuthBaseUri, string clientId, Uri redirectUri, string display, IEnumerable<string> scopes)
            _clientId = clientId;
            _redirectUri = redirectUri;
            _oAuthBaseUri = oAuthBaseUri;
            _dispaly = display;
            _scopes = scopes;
        }

        public virtual async Task<Token> AuthorizeAsync()
        {
            var token = await GetAccessTokenAsync(GenerateOAuthUri(_scopes).AbsoluteUri);
            return token;
        }
       
        protected Task<Token> GetAccessTokenAsync(string authUri)
        {
            var completion = new TaskCompletionSource<Token>();
            var token = new Token();

            var thread = new Thread(() =>
            {
                using (var browser = new BrowserForm())
                {
                    browser.Navigated += (sender, eventArgs) =>
                    {
                        if (eventArgs.Url.AbsoluteUri.Contains("access_token"))
                        {
                            var uri = new Uri(eventArgs.Url.AbsoluteUri.Replace('#', '?'));
                            var query = HttpUtility.ParseQueryString(uri.Query);
                            token.AccessToken = query["access_token"];
                            token.UserId = query["user_id"];
                            token.ExpiresIn = long.Parse(query["expires_in"]);
                            token.Expires = DateTime.Now.AddSeconds(token.ExpiresIn);
                            completion.SetResult(token);
                            browser.Close();
                            Application.ExitThread();
                        }
                        else
                        {
                            browser.Show();
                        }
                    };          
                    browser.Navigate(authUri);
                }
                Application.Run();
            });

            thread.SetApartmentState(ApartmentState.STA);
            thread.Start();

            return completion.Task;
        }

        protected Uri GenerateOAuthUri(IEnumerable<string> scopes)
        {
            var uriBuilder = new UriBuilder(_oAuthBaseUri);
            var query = HttpUtility.ParseQueryString(uriBuilder.Query);
            query["scope"] = string.Join(",", scopes);
            query["redirect_url"] = _redirectUri.AbsoluteUri;
            query["client_id"] = _clientId;
            query["response_type"] = "token";
            query["display"] = _dispaly;
            uriBuilder.Query = query.ToString();
            return uriBuilder.Uri;
        }
    }

public class Token
    {
        public string UserId { get; set; }
        public string AccessToken { get; set; }
        public string RefreshToken { get; set; }
        public DateTime Expires { get; set; }
        public long ExpiresIn { get; set; }
    }

Если тип не известен при компиляции, а будет известен только в рантайме. Например, метод принимает object в качестве параметра (метод Foo ниже)

public static class DynamicOverride
{
	private static void Print(dynamic arg)
	{
		Console.Write("No override was found for type {0}", arg.GetType());
	}
	private static void Print(int gp)
	{
		Console.WriteLine("The type is int");
	}
	private static void Print(string gp)
	{
		Console.WriteLine("The type is string");
	}
	private static void Print(bool gp)
	{
		Console.WriteLine("The type is boolean");
	}

	static void Main(string[] args)
	{
		Foo(123);
		Foo("string");
		Foo(true);
		Foo(12.3);
		Console.ReadKey();
	}

	static void Foo(object obj)
	{
		Print((dynamic)obj);
	}
}

//Результат:
//The type is int
//The type is string
//The type is boolean
//No override was found for type System.Double

Данный стеш не является реализацией какого-то полезного функционала, а служит лишь для ознакомления с нововведениями синтаксиса шестой версии языка C#

// ******************
// 1. Интерполяция строк
const string name = "Vasily";
var text = $"My name is {name}.";   // My name is Vasily

// ******************
// 2. Индексный инициализатор
var list = new Dictionary<string, int>
{
    ["Three"] = 3,
    ["Four"] = 4
};

// ******************
// 3. Новый способ инициализации auto-implemented свойств
public int MyProp { get; } = 3;

// ******************
// 4. Возможность объявления методов класса в стрелочной нотации лямбда
class MyClass {
	public static int Mul3(int x) => 3*x; // MyClass.Mul3(4) --> 12
}

// ******************
// 5. Оператор .? - это самое ожидаемое мной нововведение в синтаксис языка
// и я с нетерпением жду, когда другие языки (в частности JavaScript и PHP) реализуют эту идею.
// Данный оператор позволяет решить проблему проверки на null в многовложенных цепочках обращений:
var list = new List<Person>() { new Person() }; 
var chiefSurname = list[0]?.Chief?.Surname;  // Если Chief == null, в chiefSurname будет записано null
PropertyChanged?.Invoke(e)  // Вызов обработчика события при условии, что он сущестует

// ******************
// 6. nameof() - это не метод, это инструкция, аналогичная инструкции typeof(), 
// возвращает имя объекта/свойства в виде строки
var person = new Person();
Console.WriteLine(nameof(person.Surname));  // --> "Surname"

// ******************
// 7. Условные catch-блоки
try
{
    throw new ArgumentException("Blablabla","myparam");
}
// В этот catch-блок будет выполнен вход только при соответствии условия
catch (ArgumentException e) when (e.ParamName == "myparam")
{
    Console.WriteLine($"Argument {e.ParamName} is missing");
}
// Все остальные ошибки типа ArgumentException будут обработаны этим catch-блоком
catch (ArgumentException e)
{
    Console.WriteLine("Any unknown argument");
}

// ******************
// 8. Статический импорт методов. Никогда не используйте эту возможность! 
// Привожу пример лишь для полноты изложения
using static System.Console;
// теперь статические методы класса Console можно использовать без указания имени класса
ReadLine();

// ******************
// 9. Появилась возможность использовать await в блоках catch/finally
async static void Test()
{
    try
    {
        throw new Exception();
    }
    catch (Exception e)
    {
        await LogResultAsync("Site download failed", e);
    }
}

async static Task LogResultAsync(string msg, Exception e)
{
    await Task.Delay(1000).ContinueWith((r) => { Console.WriteLine(msg); });
}

Игра "Змейка" реализованная в исходном коде (Квайн). Для каждого следующего шага необходимо компилировать код и сохранять его в файл (пока только Windows):

Продолжение

For reversing the linked list

public void Reverse()
{
	Node cur = _root;
	Node prev = null;

	while(cur != null)
	{
		Node next = cur.Next;
		cur.Next = prev;
		prev = cur;
		cur = next;
	}
	_root = prev;
}

Использование string hello = "Hello"; int i = 42; dynamic il = new IL<int>(/аргументы метода/new object[] { hello, i }); //тело метода il.Emit(OpCodes.Ldarg_0); il.EmitCall(OpCodes.Call, typeof(Console).GetMethod("WriteLine", new Type[] { typeof(string) }), null); il.Emit(OpCodes.Ldarg_1); il.Emit(OpCodes.Ret); //выполняем и получаем результат int j = il.Exec(); Console.WriteLine(j); Console.ReadLine();

internal class IL<T>: DynamicObject 
{
	private object[] args;
	private DynamicMethod method;
	private ILGenerator generator;
	
	public IL(object[] args) 
	{
		this.args = args;
		Type[] _args = new Type[args.Length];
		for (int i = 0; i < args.Length; i++)
			_args[i] = args[i].GetType();
		this.method = new DynamicMethod("Method", typeof(T), _args, typeof(string).Module);
		this.generator = this.method.GetILGenerator(); 
	}
	
	public override bool TryInvokeMember(InvokeMemberBinder binder, object[] args, out object result) 
	{
		try 
		{
			return null == (result = typeof(ILGenerator).InvokeMember(binder.Name, BindingFlags.InvokeMethod, null, this.generator, args));
		} catch 
		{
			return null != (result = null); 
		}
	}
	
	public T Exec() 
	{
		return (T)this.method.Invoke(this, this.args); 
	}
}

несмотря на наличие цикла, генерация случайного числа для интервалов значительно меньше диапазона [0; uint.MaxValue], скорее всего будет выполняться 1 раз.

const uint RandomStart = 1048576;
const uint RandomEnd = 33554431;
const uint RandomLength = RandomEnd - RandomStart + 1;

private static readonly ThreadLocal<Random> RandomWrapper = new ThreadLocal<Random>(() => {
	int seed = Environment.TickCount;
	return new Random(Interlocked.Increment(ref seed));
});

public static uint GetRandom()
{
	uint limit = uint.MaxValue - uint.MaxValue % RandomLength;
	uint uRandom;
	do
	{
		byte[] buf = new byte[4];
		uRandom = BitConverter.ToUInt32(RandomWrapper.Value.NextBytes(buf), 0);
	} while (uRandom > limit);
	return uRandom % RandomLength + RandomStart;
}

Генерация последовательности с заданным условием

 private static IEnumerable<int> GetNumber(int startValue,Func<int,int> func )
        {
            var nextValue = startValue;
            while (true)
            {
                yield return nextValue;
                nextValue = func(nextValue);
            }
        }
var x = GetNumber(1, i => i + 1).Where(i=>i%2==0).Take(100).ToList();