using Spire.Xls;
using System;
using System.Collections.Generic;
using System.Drawing.Printing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace PrintPreviewTest
{
    class Program
    {
        static void Main(string[] args)
        {
            //打印参数对话框
            PrintDialog printdialog = new PrintDialog();

            //使用Spire加载文档
            Workbook workbook = new Workbook();
            workbook.LoadFromFile(args[0]);

            //预设参数
            Worksheet sheet = workbook.Worksheets[0];
            //设置打印纸张大小
            sheet.PageSetup.PaperSize = PaperSizeType.PaperA4;
            //设置打印方向
            sheet.PageSetup.Orientation = PageOrientationType.Portrait;
            //设置打印区域
            sheet.PageSetup.PrintArea = "B2:F8";
            //打印标题
            sheet.PageSetup.PrintTitleColumns = "$A:$B";
            sheet.PageSetup.PrintTitleRows = "$1:$2";
            //打印顺序
            sheet.PageSetup.Order = OrderType.DownThenOver;
            sheet.PageSetup.Order = OrderType.OverThenDown;
            //设置打印对话框属性
            PrintDialog dialog = new PrintDialog();
            dialog.AllowPrintToFile = true; dialog.AllowCurrentPage = true;
            dialog.AllowSomePages = true;
            //设置单面打印
            dialog.PrinterSettings.Duplex = Duplex.Simplex;
            //设置打印页面范围
            dialog.PrinterSettings.FromPage = 0;
            dialog.PrinterSettings.ToPage = 8;
            dialog.PrinterSettings.PrintRange = PrintRange.SomePages;
            //设置打印份数
            dialog.PrinterSettings.Copies = 5;
            //设置打印机名称
            dialog.PrinterSettings.PrinterName = "HP LasterJet P1007";


            //关联
            printdialog.Document = workbook.PrintDocument;

            if(printdialog.ShowDialog() == DialogResult.OK)
            {
                //根据对话框重设参数
                workbook.PrintDocument.PrinterSettings = printdialog.PrinterSettings;
                PrintPreviewDialog previewDialog = new PrintPreviewDialog();
                previewDialog.Document = workbook.PrintDocument;
                previewDialog.ShowDialog();
            }
        }
    }
}

//简化前
private static IEnumerable<string> GetCollByCommon()
{
    List<string> list = new List<string>();
    list.Add("4");
    list.Add("5");
    list.Add("6");
    return list;
}

//简化后
private static IEnumerable<string> GetCollByYield()
{
    yield return "1";
    yield return "2";
    yield return "3";
}

static void Main(string[] args)
{
    Console.WriteLine("Test is beginning!");
    IEnumerable<string> yield = GetCollByYield();
    Console.WriteLine("Loop is beginning!");
    foreach (var p in yield)
        Console.WriteLine(p);
}


private static IEnumerable<string> GetCollByYield()
{
    Console.WriteLine("GetCollByYield method is called!");
    yield return "1";
    yield return "2";
    yield return "3";
}

public class ThreadTest{
    public static readonly object locker = new object();
    public void FuncWithParameter(object obj){
        lock(locker){
            Console.WriteLint(obj);
        }
    }
    public void FuncWithoutParameter(){
        lock(locker){
            Console.WriteLine("无参方法")
        }
    }
}
public class Program{
    static void Main(string[] args){
        ThreadTest test = new ThreadTest();
        Thread threadWithParameter = new Thread(new ParameterizedThreadStart(test.FuncWithParameter));
        Thread threadWithoutParameter = new Thread(new ThreadStart(test.FuncWithoutParameter));
        threadWithParameter.Start("有参方法");
        threadWithoutParameter.Start();
    }
}

public class Program{
    //ManualResetEvent
    static AutoResetEvent autoResetEvent = new AutoResetEvent(false);//初始设置为false为默认阻塞线程
    static void FuncAutoResetEvent(){
        autoResetEvent.WaitOne();//等待autoResetEvent的Set信号，执行后状态自动设置为false，保证只有一个进程进入，而ManualResetEvent激活后不再设回false，可以同时唤醒多个线程。
        Console.WriteLine("线程继续执行.......");
    }
    static void Main(string[] args){
        Thread thread = new Thread(new ThreadStart(FuncAutoResetEvent));
        thread.Start();
        ConsoleKeyInfo key = Console.ReadKey();
        if(key.Key == ConsoleKey.Y){
            autoResetEvent.Set();
        }
    }
}

Action<int> setVal = (i) => {this.myTxtBox.Text == i.ToString()};
this.myTxtBox.Invoke(setVal,i);
//Control.Invoke(Delegate method,params object[] args) 在拥有控件的基础窗口句柄的线程上，用指定的自变量列表执行指定委托。

class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hello World!");
            AsyncCount count = new AsyncCount(Program.count);
            IAsyncResult result = count.BeginInvoke(1, 100, out int threadId, null, null);
            Thread.Sleep(1000);
            Console.WriteLine("回到主线程");
            Console.WriteLine("开始等待子线程");
            int cou = count.EndInvoke(out threadId, result);
            Console.WriteLine($"结果是{cou}");
        }
        public static int count(int start, int end, out int threadId)
        {
            Console.WriteLine("进入子线程");
            int count = 0;
            for (int i = start; i < end; i++)
            {
                Thread.Sleep(100);
                count += i;
            }
            threadId = Thread.CurrentThread.ManagedThreadId;
            return count;
        }
        public delegate int AsyncCount(int start, int end, out int threadId);
    }

public class CountModel
    {
        public int Count(int start,int end);
        public void CountAsync(int start,int end);
        public void CountAsync(int start,int end,object userState);
        public event CountCompletedEventHandler CountCompleted;
    }

public class CountModel
    {
        public int Count(int start,int end)
        {
            Console.WriteLine("同步线程开始");
            int count = 0;
            for (int i = start; i < end; i++)
            {
                Thread.Sleep(1000);
                count += i;
            }
            Console.WriteLine("同步线程完成");

            return count;
        }
        public void CountAsync(int start,int end,object userState)
        {
            Thread thread = new Thread(new ThreadStart(() =>
            {
                Console.WriteLine("异步线程开始");
                int count = 0;
                for (int i = start; i < end; i++)
                {
                    Thread.Sleep(1000);
                    count += i;
                }
                CountCompleted?.Invoke(this, new CountCompletedEventArgs() { Result = count });
                Console.WriteLine("异步线程完成");
            }));
            thread.Start();
        }
        public event CountCompletedEventHandler CountCompleted;
        public delegate void CountCompletedEventHandler(object sender, CountCompletedEventArgs args);
        public class CountCompletedEventArgs
        {
            public int Result;
        }
    }

public class CountModel
    {
        public Task<int> CountAsync(int start,int end,object userState)
        {
            return Task.Run(()=>{
                int count = 0;
                for (int i = start; i < end; i++)
                {
                    Thread.Sleep(1000);
                    count += i;
                }
                return count;
            })
        }
    }

//第一种返回Task，可等待
public async Task MethodAsync(int input){
    await Task.Run(()=>{
        Console.WriteLine(input);
    })
}
//第二种返回Task<TResult>，可等待
public async Task<int> MethodAsync(int input){
    return await Task.Run(()=>{
        return input;
    })
}
//第三种无返回，不可等待
public async void MethodAsync(int input){
    await Task.Run(()=>{
        Console.WriteLine(input)
    })
}

Process p = new Process();
p.StartInfo.FileName = "cmd.exe";   //调用的exe
p.StartInfo.UseShellExecute = false;
p.StartInfo.RedirectStandardInp= true;
p.StartInfo.RedirectStandardOutp= true;
p.StartInfo.CreateNoWindow = false;
p.Start();
p.StandardInput.WriteLine("cd "rootPath);
//等待执行结束
p.WaitForExit();

Environment.SetEnvironmentVariable("","");

public class LongArray<T> : IDisposable where T : struct
{
    private IntPtr _head;
    private Int64 _capacity;
    private UInt64 _bytes;
    private Int32 _elementSize;

    public LongArray(long capacity)
    {
        if (_capacity < 0) throw new ArgumentException("The capacity can not be negative");
        _elementSize = SizeOf(default(T));
        _capacity = capacity;
        _bytes = (ulong)capacity * (ulong)_elementSize;
        _head = AllocHGlobal((IntPtr)_bytes);
    }

    public T this[long index]
    {
        get
        {
            IntPtr p = _getAddress(index);
            T val = (T)System.Runtime.InteropServices.Marshal.PtrToStructure(p, typeof(T));
            return val;
        }
        set
        {
            IntPtr p = _getAddress(index);
            StructureToPtr(value, p, true);
        }
    }

    protected bool disposed = false;
    public void Dispose()
    {
        if (!disposed)
        {
            FreeHGlobal((IntPtr)_head);
            disposed = true;
        }
    }

    public IntPtr _getAddress(long index)
    {
        if (disposed) 
            throw new ObjectDisposedException("Can't access the array once it has been disposed!");
        if (index < 0) 
            throw new IndexOutOfRangeException("Negative indices are not allowed");
        if (!(index < _capacity)) 
            throw new IndexOutOfRangeException("Index is out of bounds of this array");
        return (IntPtr)((ulong)_head + (ulong)index * (ulong)(_elementSize));
    }
}