using System;
using System.Collections.Generic;

namespace SortedSetTest
{
   class Program
   {
       static void sample1()
       {
           var setRange = new SortedSet<int> { 2, 5, 6, 2, 1, 4, 8 };

           foreach (var i in setRange)
           {
               Console.WriteLine(i);
           }
       }

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

using System;
using System.Collections.Generic;

namespace SortedSetTest
{
   class Program
   {      
       static void sample2()
       {
           var setRange = new SortedSet<int>();
           var random = new Random();

           for (int counter = 0; counter < 100; counter++)
           {
               var rnd = random.Next(-180, 181);
               if (!setRange.Add(rnd))
               {
                   Console.WriteLine("Couldn't add {0}", rnd);
               }
           }

           Console.WriteLine("Result set:");
           foreach (var item in setRange)
           {
               Console.WriteLine(item);
           }
       }

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

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

namespace SortedSetTest
{
   class FileInfo
   {
       public string Name { set; get; }
       public long Size { set; get; }
   }

   class FileInfoComparer : IComparer<FileInfo>
   {
       public int Compare(FileInfo x, FileInfo y)
       {
           var caseiComp = new CaseInsensitiveComparer();
           return caseiComp.Compare(x.Name, y.Name);
       }
   }


   class Program
   {

       static void sample3()
       {
           var setRange = new SortedSet<FileInfo>(new FileInfoComparer())
                              {
                                  new FileInfo
                                      {
                                          Name = "file1.txt",
                                          Size = 100
                                      },
                                  new FileInfo
                                      {
                                          Name = "file2.txt",
                                          Size = 10
                                      },
                                      new FileInfo
                                          {
                                          Name = "file3.txt",
                                          Size = 300
                                      }
                              };

           foreach (var item in setRange)
           {
               Console.WriteLine(item.Name);
           }
       }

       static void Main()
       {
           sample3();

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

<?xml version="1.0" encoding="UTF-8"?>
<transcript>
<text start="23.49" dur="5.97">
  &amp;gt;&amp;gt;Commentator: We have here today, Steve with
  us whom I met not too long ago at something
</text>
...
</transcript>

using System;
using System.Linq;
using System.Text;
using System.Web;
using System.Xml.Linq;

namespace YtSubs
{
  public class GoogleXmlToSrt
  {
      public string ConvertXmlToSrt(string url)
      {
          var transcript = loadTranscript(url);

          var srtBuf = new StringBuilder();
          var lineNumber = 0;

          foreach (var item in transcript.Root.Elements("text"))
          {
              lineNumber++;
              srtBuf.Append(lineNumber.ToString());

              var timeLine = getTimeLine(item);
              srtBuf.AppendFormat("{0}{1} --> {2}{3}", Environment.NewLine, timeLine.Item1, timeLine.Item2, Environment.NewLine);

              var msg = decodeText(item);
              srtBuf.AppendLine(msg + Environment.NewLine);
          }
          return srtBuf.ToString();
      }

      private static XDocument loadTranscript(string url)
      {
          var transcript = XDocument.Load(url);

          if (transcript.Root == null)
              throw new InvalidOperationException("couldn't load received data.");
          return transcript;
      }

      private static string decodeText(XElement text)
      {
          var textValue = text.Value.Split('\n');
          var msg = textValue.Aggregate(
                  string.Empty, (current, line) =>
                  current + (HttpUtility.HtmlDecode(line.Trim()) + Environment.NewLine)
                  );
          return msg.Trim();
      }

      private static int fractionalPart(string data)
      {
          var idx = data.IndexOf(".");
          if (idx == -1) return 0;
          var fractionalPart = data.Substring(idx + 1);
          if (fractionalPart.Length == 1) //3.4 --> 3.400
              return int.Parse(fractionalPart + "00");

          if (fractionalPart.Length == 2) //3.04 --> 3.040
              return int.Parse(fractionalPart + "0");

          return int.Parse(fractionalPart.Substring(0, 3));
      }

      private Tuple<string, string> getTimeLine(XElement text)
      {
          var startTs = getStartTs(text);
          TimeSpan endTs = getEndTs(text, startTs);
          return new Tuple<string, string>(timeSpanToString(startTs), timeSpanToString(endTs));
      }

      private static TimeSpan getStartTs(XElement text)
      {
          var startData = text.Attribute("start");
          if (startData == null)
              throw new InvalidOperationException("This is not a valid subtitle file.");

          var start = startData.Value;
          var startTs = new TimeSpan(0, 0, 0, (int)Math.Truncate(double.Parse(start)), fractionalPart(start));
          return startTs;
      }

      private static TimeSpan getEndTs(XElement text, TimeSpan startTs)
      {
          TimeSpan endTs;
          var durData = text.Attribute("dur");
          if (durData == null)
          {
              endTs = startTs + new TimeSpan(0, 0, 0, 3, 0);
          }
          else
          {
              var dur = durData.Value;
              var durTs = new TimeSpan(0, 0, 0, (int)Math.Truncate(double.Parse(dur)), fractionalPart(dur));
              endTs = startTs + durTs;
          }
          return endTs;
      }

      private static string timeSpanToString(TimeSpan lineTs)
      {
          return string.Format("{0}:{1}:{2},{3}",
                      lineTs.Hours.ToString("D2"),
                      lineTs.Minutes.ToString("D2"),
                      lineTs.Seconds.ToString("D2"),
                      lineTs.Milliseconds.ToString("D3"));
      }
  }
}

using System.IO;

namespace YtSubs
{
  class Program
  {
      static void Main(string[] args)
      {
          var url = "http://video.google.com/timedtext?hl=en&v=-PA-buwI3q4&lang=en";
          //var url = "subtitle.xml";
          var srtBuf = new GoogleXmlToSrt().ConvertXmlToSrt(url);
          File.WriteAllText("-PA-buwI3q4.srt", srtBuf);
      }
  }
}

        /// <summary>
        /// Validate IR National Code
        /// </summary>
        /// <param name="nationalcode">National Code</param>
        /// <param name="lastNumber">Last Number Of National Code</param>
        /// <returns></returns>
        public static bool IsValidNationalCode(this string nationalcode, out int lastNumber)
        {
            lastNumber = -1;
            if (!nationalcode.IsItNumber()) return false;
            var invalid = new[]
                                    {
                                        "0000000000", "1111111111", "2222222222", "3333333333", "4444444444", "5555555555",
                                        "6666666666", "7777777777", "8888888888", "9999999999"
                                    };
            if (invalid.Contains(nationalcode)) return false;
            var array = nationalcode.ToCharArray();
            if (array.Length != 10) return false;
            var j = 10;
            var sum = 0;
            for (var i = 0; i < array.Length - 1; i++)
            {
                sum += Int32.Parse(array[i].ToString(CultureInfo.InvariantCulture)) * j;
                j--;
            }

            var diff = sum % 11;

            if (diff < 2)
            {
                lastNumber = diff;
                return diff == Int32.Parse(array[9].ToString(CultureInfo.InvariantCulture));
            }
            var temp = Math.Abs(diff - 11);
            lastNumber = temp;
            return temp == Int32.Parse(array[9].ToString(CultureInfo.InvariantCulture));
        }

private enum VisiteType
        {
            FirstVisite = 2,
            Reviste = 4,
        }

[Index(nameof(Url))]
public class Blog
{
    public int BlogId { get; set; }
    public string Url { get; set; }
}

[Index(nameof(Url), Name = "Index_Url")]

[Index(nameof(FirstName), nameof(LastName))]
public class Person
{
    public int PersonId { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
}

[Index(nameof(Url), IsUnique = true)]
public class Blog
{
    public int BlogId { get; set; }
    public string Url { get; set; }
}

namespace FakingExample
{
    public class CartToShim
    {
        public int CartId { get; private set; }
        public int UserId { get; private set; }
        private List<CartItem> _cartItems = new List<CartItem>();
        public ReadOnlyCollection<CartItem> CartItems { get; private set; }
        public DateTime CreateDateTime { get; private set; }
 
        public CartToShim(int cartId, int userId)
        {
            CartId = cartId;
            UserId = userId;
            CreateDateTime = DateTime.Now;
            CartItems = new ReadOnlyCollection<CartItem>(_cartItems);
        }
 
        public void AddCartItem(int productId)
        {
            var cartItemId = DataAccessLayer.SaveCartItem(CartId, productId);
            _cartItems.Add(new CartItem(cartItemId, productId));
        }
    }
}

public class CartItem
    {
        public int CartItemId { get; private set; }
        public int ProductId { get; private set; }
 
        public CartItem(int cartItemId, int productId)
        {
            CartItemId = cartItemId;
            ProductId = productId;
        }
    }

[TestMethod]
        public void AddCartItem_GivenCartAndProduct_ThenProductShouldBeAddedToCart()
        {
            //Create a context to scope and cleanup shims
            using (ShimsContext.Create())
            {
                int cartItemId = 42, cartId = 1, userId = 33, productId = 777;
 
                //Shim SaveCartItem rerouting it to a delegate which 
                //always returns cartItemId
                Fakes.ShimDataAccessLayer.SaveCartItemInt32Int32 = (c, p) => cartItemId;
 
                var cart = new CartToShim(cartId, userId);
                cart.AddCartItem(productId);
 
                Assert.AreEqual(cartId, cart.CartItems.Count);
                var cartItem = cart.CartItems[0];
                Assert.AreEqual(cartItemId, cartItem.CartItemId);
                Assert.AreEqual(productId, cartItem.ProductId);
            }
        }

public interface ICartSaver
    {
        int SaveCartItem(int cartId, int productId);
    }

public class CartSaver : ICartSaver
    {
        public int SaveCartItem(int cartId, int productId)
        {
            using (var conn = new SqlConnection("RandomSqlConnectionString"))
            {
                var cmd = new SqlCommand("InsCartItem", conn);
                cmd.CommandType = CommandType.StoredProcedure;
                cmd.Parameters.AddWithValue("@CartId", cartId);
                cmd.Parameters.AddWithValue("@ProductId", productId);
 
                conn.Open();
                return (int)cmd.ExecuteScalar();
            }
        }
    }

[TestMethod]
        public void AddCartItem_GivenCartAndProduct_ThenProductShouldBeAddedToCart()
        {
            int cartItemId = 42, cartId = 1, userId = 33, productId = 777;
 
            //Stub ICartSaver and customize the behavior via a 
            //delegate, ro return cartItemId
            var cartSaver = new Fakes.StubICartSaver();
            cartSaver.SaveCartItemInt32Int32 = (c, p) => cartItemId;
 
            var cart = new CartToStub(cartId, userId, cartSaver);
            cart.AddCartItem(productId);
 
            Assert.AreEqual(cartId, cart.CartItems.Count);
            var cartItem = cart.CartItems[0];
            Assert.AreEqual(cartItemId, cartItem.CartItemId);
            Assert.AreEqual(productId, cartItem.ProductId);
        }

dotnet tool install -g dotnet-ignore

dotnet tool list -g

dotnet tool update -g dotnet-ignore

dotnet tool uninstall -g dotnet-ignore

<PropertyGroup>
    <PackAsTool>true</PackAsTool>
    <ToolCommandName>dotnet-mytool</ToolCommandName>
    <PackageOutputPath>./nupkg</PackageOutputPath>
</PropertyGroup>

dotnet tool install --global --add-source ./nupkg globaltools

dotnet-mytool

https://www.nuget.org/packages/McMaster.Extensions.CommandLineUtils

[Command(Description="Add a new note")]
    public class NewNote
    {
        [Required]
        [Option(Description="title of note")]
        public string Title{ get; set; }

        [Option(Description="content of note")]
        public string Body{ get; set; }
    }

[Command(Description="Add a new note")]
    public class NewNote:BaseClass
    {
        [Required]
        [Option(Description="title of note")]
        public string Title{ get; set; }

        [Option(Description="content of note")]
        public string Body{ get; set; }

        public void OnExecute(IConsole console)
        {

            var dir = GetBaseDirectory();
            if(!Directory.Exists(dir))
            {
                Directory.CreateDirectory(dir);
            }
            var filePath = Path.Combine(dir, Title + ".txt");
            File.WriteAllText(filePath, Body);
            console.WriteLine("the note is saved");
        }
    }

public class BaseClass
    {
        protected string GetBaseDirectory(){
            var baseDirectory = Environment.CurrentDirectory;
            return (Path.Combine(baseDirectory, "notes"));
        }
    }

public class List:BaseClass
    {
        [Option(Description="search a phrase in notes title")]
        public string Grep{ get; set; }
        public void OnExecute(IConsole console)
        {
            try
            {
                var baseDirectory = GetBaseDirectory();

                var dir = new DirectoryInfo(baseDirectory);
                var files = dir.GetFiles();
                foreach(var file in files)
                {
                    if(!String.IsNullOrEmpty(Grep) && !file.Name.Contains(Grep))
                        continue;

                    console.WriteLine(Path.GetFileNameWithoutExtension(file.Name));
                }
            }
            catch (Exception e)
            {
                console.WriteLine(e.Message);
            }
        }
    }

[Command(Description="show contnet of note")]
    public class Show:BaseClass
    {
        [Required]
        [Option(Description="title of note")]
        public string Title{ get; set; }


        public void OnExecute(IConsole console){
            var baseDirectory = GetBaseDirectory();
            var file = Path.Combine(baseDirectory, Title+".txt");

            if(!File.Exists(file))
            {
                console.WriteLine("The Note NotFound...");
                return;
            }
            console.WriteLine(File.ReadAllText(file));

        }
    }

    [Command(Description="An Immediate Note Saver")]
    [Subcommand(typeof(NewNote),typeof(List),typeof(Show))]
    class Program
    {
        static int Main(string[] args)
        {
            return CommandLineApplication.Execute<Program>(args);
        }

        public int OnExecute(CommandLineApplication app, IConsole console)
        {
            console.WriteLine("You must specify a subcommand.");
            console.WriteLine();
            app.ShowHelp();
            return 1;
        }
    }

        static int Main(string[] args)
        {
            return CommandLineApplication.Execute<Program>(args);
        }

PS D:\projects\Samples\globaltools> dotnet-notes new-note -t "sample1" -b "this is body"
the note is saved
PS D:\projects\Samples\globaltools> dotnet-notes new-note -t "test1" -b "this is body of another note"
the note is saved
PS D:\projects\Samples\globaltools> dotnet-notes list
sample1
test1
PS D:\projects\Samples\globaltools> dotnet-notes list -g sa
sample1
PS D:\projects\Samples\globaltools> dotnet-notes show -t sample1
this is body