private int n1, n2;

private void FirstCall()
{
  Service.GetRandomNumber(10, SecondCall);
}

private void SecondCall(int number)
{
  n1 = number;
  Service.GetRandomNumber(n1, ThirdCall);
}

private void ThirdCall(int number)
{
  n2 = number;
  // etc
}

private void FetchNumbers()
{
 int n1 = Service.GetRandomNumber(10);
 int n2 = Service.GetRandomNumber(n1);
}

private void FetchNumbers()
{
  int n1, n2;

  Service.GetRandomNumber(10, result =>
                                  {
                                      n1 = result;
                                      Service.GetRandomNumber(n1, secondResult =>
                                                                      {
                                                                          n2 = secondResult;
                                                                      });
                                  });
}

using System;
using System.Collections.Generic;
using System.Threading;

namespace CoroutinesSample
{
  class Program
  {
      static void printAll()
      {
          foreach (int x in integerList())
          {
              Console.WriteLine(x);
          }
      }

      static IEnumerable<int> integerList()
      {
          yield return 1;
          Thread.Sleep(1000);
          yield return 2;
          yield return 3;
      }

      static void Main()
      {
          printAll();
      }
  }
}

private bool MoveNext()
{
  switch (this.<>1__state)
  {
      case 0:
          this.<>1__state = -1;
          this.<>2__current = 1;
          this.<>1__state = 1;
          return true;

      case 1:
          this.<>1__state = -1;
          Thread.Sleep(0x3e8);
          this.<>2__current = 2;
          this.<>1__state = 2;
          return true;

      case 2:
          this.<>1__state = -1;
          this.<>2__current = 3;
          this.<>1__state = 3;
          return true;

      case 3:
          this.<>1__state = -1;
          break;
  }
  return false;
}

using System.AddIn.Pipeline;
using System.AddIn.Contract;

namespace CalculatorConract
{
  [AddInContract]
  public interface ICalculatorContract : IContract
  {
      double Operate(string operation, double a, double b);
  }
}

using System;
using CalculatorConract.AddInViews;
using System.AddIn;

namespace CalculatorAddIn
{
   [AddIn]
  public class MyCalculatorAddIn : ICalculator
  {
      public double Operate(string operation, double a, double b)
      {
          throw new NotImplementedException();
      }
  }
}

using System;
using CalculatorConract.AddInViews;
using System.AddIn;

namespace CalculatorAddIn
{
  [AddIn("افزونه یک", Description = "توضیحات", Publisher = "نویسنده", Version = "نگارش یک")]
  public class MyCalculatorAddIn : ICalculator
  {
      public double Operate(string operation, double a, double b)
      {
          switch (operation)
          {
              case "+":
                  return a + b;
              case "-":
                  return a - b;
              case "*":
                  return a * b;
              default:
                  throw new NotSupportedException("عملیات مورد نظر توسط این افزونه پشتیبانی نمی‌شود");
          }
      }
  }
}

using System;
using System.AddIn.Hosting;
using CalculatorConract.HostViews;

namespace Calculator
{
  class Program
  {
      private static ICalculator _calculator;

      static void doOperation()
      {
          Console.WriteLine("1+2: {0}", _calculator.Operate("+", 1, 2));
      }

      static void Main(string[] args)
      {
          //مسیر پوشه ریشه مربوطه به خط لوله افزونه‌ها
          string path = Environment.CurrentDirectory;

          //مشخص سازی مسیر خواندن و کش کردن افزونه‌ها
          AddInStore.Update(path);

          //یافتن افزونه‌هایی سازگار با شرایط قرارداد پروژه
          //در اینجا هیچ افزونه‌ای بارگذاری نمی‌شود
          var addIns = AddInStore.FindAddIns(typeof(ICalculator), path);

          //اگر افزونه‌ای یافت شد
          if (addIns.Count > 0)
          {
              var addIn = addIns[0]; //استفاده از اولین افزونه
              Console.WriteLine("1st addIn: {0}", addIn.Name);

              //فعال سازی افزونه و همچنین مشخص سازی سطح دسترسی آن
              _calculator = addIn.Activate<ICalculator>(AddInSecurityLevel.Intranet);

              //یک نمونه از استفاده آن
              doOperation();
          }

          Console.WriteLine("Press a key...");
          Console.ReadKey();
      }
  }
}

//فعال سازی افزونه و همچنین مشخص سازی سطح دسترسی آن
//همچنین جدا سازی پروسه اجرایی افزونه از هاست
   _calculator = addIn.Activate<ICalculator>(
                  new AddInProcess(),
                  AddInSecurityLevel.Intranet);

public interface IBackgroundTaskQueue : ISingletonDependency
{
    void QueueBackgroundWorkItem(Func<CancellationToken, IServiceProvider, Task> workItem);

    Task<Func<CancellationToken, IServiceProvider, Task>> DequeueAsync(
        CancellationToken cancellationToken);
}

internal class BackgroundTaskQueue : IBackgroundTaskQueue
{
    private readonly ConcurrentQueue<Func<CancellationToken, IServiceProvider, Task>> _workItems =
        new ConcurrentQueue<Func<CancellationToken, IServiceProvider, Task>>();

    private readonly SemaphoreSlim _signal = new SemaphoreSlim(0);

    public void QueueBackgroundWorkItem(
        Func<CancellationToken, IServiceProvider, Task> workItem)
    {
        if (workItem == null)
        {
            throw new ArgumentNullException(nameof(workItem));
        }

        _workItems.Enqueue(workItem);
        _signal.Release();
    }

    public async Task<Func<CancellationToken, IServiceProvider, Task>> DequeueAsync(
        CancellationToken cancellationToken)
    {
        await _signal.WaitAsync(cancellationToken);
        _workItems.TryDequeue(out var workItem);

        return workItem;
    }
}

public class QueuedHostedService : BackgroundService
{
    private readonly IServiceScopeFactory _factory;
    private readonly ILogger _logger;
    private readonly IBackgroundTaskQueue _queue;

    public QueuedHostedService(
        IBackgroundTaskQueue queue,
        IServiceScopeFactory factory,
        ILoggerFactory loggerFactory)
    {
        _factory = factory ?? throw new ArgumentNullException(nameof(factory));
        _queue = queue ?? throw new ArgumentNullException(nameof(queue));
        _logger = loggerFactory.CreateLogger<QueuedHostedService>();
    }


    protected override async Task ExecuteAsync(CancellationToken cancellationToken)

    {
        _logger.LogInformation("Queued Hosted Service is starting.");

        while (!cancellationToken.IsCancellationRequested)
        {
            var workItem = await _queue.DequeueAsync(cancellationToken);

            try
            {
                using (var scope = _factory.CreateScope())
                {
                    await workItem(cancellationToken, scope.ServiceProvider);
                }
            }
            catch (Exception ex)
            {
                _logger.LogError(ex,
                    $"Error occurred executing {nameof(workItem)}.");
            }
        }

        _logger.LogInformation("Queued Hosted Service is stopping.");
    }
}

public class InvoiceService : IInvoiceService
{
   private readonly IBackgroundTaskQueue _queue;
   
   public InvoiceService(IBackgroundTaskQueue queue)
   {
     _queue = queue ?? throw new ArgumentNullException(nameof(queue));
   }
   
   public Print(InvoiceModel model)
   {
      _queue.QueueBackgroundWorkItem((token, provider)=>
      {
      //todo: print
      return Task.Task.CompletedTask;
      })
   }
}

using System.Collections.Generic;
using System.Reflection;
using Microsoft.Office.Interop.Outlook;

namespace GAL
{
   //add a reference to Microsoft Outlook 12.0 Object Library
   class COutLook
   {
       public struct User
       {
           public string Name;
           public string Email;
       }

       public static List<User> ExchangeServerEmailAddresses(string userName)
       {
           List<User> res = new List<User>();
           //Create Outlook application
           Application outlookApp = new Application();
           //Get Mapi NameSpace and Logon
           NameSpace ns = outlookApp.GetNamespace("MAPI");
           ns.Logon(userName, Missing.Value, false, true);

           //Get Global Address List
           AddressLists addressLists = ns.AddressLists;
           AddressList globalAddressList = addressLists["Global Address List"];
           AddressEntries entries = globalAddressList.AddressEntries;
           foreach (AddressEntry entry in entries)
           {
               ExchangeUser user = entry.GetExchangeUser();
               if (user != null && user.PrimarySmtpAddress != null && entry.Name != null)
                   res.Add(new User
                           {
                               Name = entry.Name,
                               Email = user.PrimarySmtpAddress
                           });
           }

           ns.Logoff();

           // Clean up.
           outlookApp = null;
           ns = null;
           addressLists = null;
           globalAddressList = null;
           entries = null;

           return res;
       }
   }
}

List<COutLook.User> data = COutLook.ExchangeServerEmailAddresses("nasiri");
foreach (var list in data)
{
  //....
}

namespace Refactoring.Day12.RefactoringSwitchStatement.Before
{
    public class Translator
    {
        public string ToPersian(string englishWord)
        {
            switch (englishWord)
            {
                case "zero":
                    return "صفر";
                case "one":
                    return "یک";
                default:
                    return string.Empty;
            }
        }
    }
}

using System.Collections.Generic;

namespace Refactoring.Day12.RefactoringSwitchStatement.After
{
    public class Translator
    {
        IDictionary<string, string> Words = new Dictionary<string, string>
        {
            { "zero", "صفر" },
            { "one", "یک" }
        };

        public string ToPersian(string englishWord)
        {
            string persianWord;
            if (Words.TryGetValue(englishWord, out persianWord))
            {
                return persianWord;
            }

            return string.Empty;
        }
    }
}

using System.Collections.Generic;

namespace Refactoring.Day12.RefactoringSwitchStatement.After
{
    public enum EnglishWord
    {
        Zero,
        One
    }

    public class Translator2
    {
        IDictionary<EnglishWord, string> Words = new Dictionary<EnglishWord, string>
        {
            { EnglishWord.Zero, "صفر" },
            { EnglishWord.One, "یک" }
        };

        public string ToPersian(EnglishWord englishWord)
        {
            return Words[englishWord];
        }
    }
}

public static int Add(int number1, int number2)
{
    // number1 is on the stack (function parameter)
    // number2 is on the stack (function parameter)

    int sum = number1 + number2;
    // sum is on the stack (local variable)

    return sum;
}

.method private hidebysig static int32 Add(int32 number1, int32 number2) cil managed
{
  .locals init (int32 V_0, int32 V_1)
  
  IL_0001:  ldarg.0 // Stack is: [2]
  IL_0002:  ldarg.1 // Stack is: [2, 5]
  IL_0003:  add     // Stack is: [7]
  IL_0004:  stloc.0 // Stack is: [] and V_0's value is: 7
  
  IL_0005:  ldloc.0 // Stack is: [7]
  IL_0006:  stloc.1 // Stack is: [] and V_1's value is: 7

  IL_0009:  ldloc.1 // Stack is: [7]
  IL_000a:  ret     // Return [7]
}

.Heap: a group of things placed, thrown, or lying one on another

var serviceCollection = new ServiceCollection();
serviceCollection.AddDataProtection();
var services = serviceCollection.BuildServiceProvider();
var protectionProvider = ActivatorUtilities.CreateInstance<ProtectionProvider>(services);
string result = protectionProvider.Encrypt(Str);