out ref params

out的使用

out 能够使我们的函数返回多个类型的值，不再受返回类型的设置；

就是相当于在方法里不仅仅给了一个返回值，被out修饰的参数的值也能带出去；

所以就是说，在方法体内被out修饰的参数，都可以在主函数内获取值来用。大致就是这样

————————————————————————————————————————————————— 

 在这里面被修饰的参数是msg，而且在方法体内部，对不同情况msg有不同的值；

所以在主函数内，我们就看到，msg被定义了一下，但是，msg的值还是方法体内的值。

  class Program
    {
        static void Main(string[] args)
        {
          
            Console.WriteLine("请输入一个用户名");
            string name = Console.ReadLine();
            Console.WriteLine("请输入一个密码");
            string pwd = Console.ReadLine();
            string msg;
            bool b = login(name, pwd, out msg);
            Console.WriteLine("登陆结果{0}",b);
            Console.WriteLine("登陆信息{0}",msg);
            Console.ReadKey();
            
        }
        //方法的作用就是：先定义好要实现一个什么功能的公式，然后在主函数里代入数据再代用方法，
        //第一步先在形参中写上out等要多余返回的参数
        //out参数
      
       
        //分别提示用户输入用户名和密码
        //写一个方法来判断用户名和输入的是否正确
        //返回给用户一个登陆结果，并且单独返回给用户一个登录信息
        //如果用户名错误，除了返回登陆结果之外，还要返回一个“用户名错误”
        public static bool login(string name,string pwd,out string msg)
        {
            //就作用户名和密码能不能匹配正确和返回相应的信息
            if (name == "lisi" && pwd == "123")
            {
                msg = "登陆成功";
                return true;
            }
            if (name == "lisi")
            {
                msg = "密码错误";
                return false;
            }
            if (pwd == "123")
            {
                msg = "用户名错误";
                return false;
            }
            else
            {
                msg = "未知错误";
                return false;
            }

         }
    }

 int numm;//这个trypase自带out返回参数的类型，F12可以进去看看他的定义
            bool num = int.TryParse(null, out numm);
          //  bool num = int.TryParse("1212", out numm);
            Console.WriteLine(num);
            Console.WriteLine(numm);
            Console.ReadKey();

 ————————————————————————————————————————————————

 ref的使用

————————————————————————————————————————————————— 

//ref 就是讲一个变量作为参数带入到一个方法中进行改变，deng这个值改变后再将改变后的值
//带回来。注意：无论方法有没有返回值，会将参数的值改变。只要参数被ref改变啦

//这个方法就没有返回值return等词，照样可以将主函数内的改变掉
//反正，我认为ref就是你在方法没有return 的时候参数只要被ref修饰，参数就会改变

其他的没啥用

————————————————————————————————————————————————— 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ref参数
{
    class Program
    {
        static void Main(string[] args)
        {
            //double money = 5000;
            ////double b= jiangjin(money);
            //jiangjin(ref money);
            //Console.WriteLine(money);
            //Console.ReadKey();
            int n1 = 10;
            int n2 = 20;
            //引入第三者进行转换
            //int temp = n1;
            //n1 = n2;
            //n2 = temp;

            //不用第三者
            //n1 = n1 - n2;//n1:-10  n2: 20
            //n2=n1+n2;//n2:10 n1;-10
            //n1=n2-n1;//n1:20 n2:10
            change(ref n1,ref n2);
            Console.WriteLine(n1);
            Console.WriteLine(n2);

            string name = "zkb";
            tom(ref name);
            Console.ReadKey();
        }
        //ref 就是讲一个变量作为参数带入到一个方法中进行改变，deng这个值改变后再将改变后的值
        //带回来。注意：无论方法有没有返回值，会将参数的值改变。只要参数被ref改变啦
        public static void jiangjin(ref double s)
        {
            //s = s + 500;
            // return 在加ref之前，是无返回值的方法，还没有写return 是有错误的，加上ref之后，在主函数中方法后面的参数+ref就可以啦
            //ref就是方法不加return 不改变方法的类型
        }
        //这个方法就没有返回值return等词，照样可以将主函数内的改变掉
        //反正，我认为ref就是你在方法没有return 的时候参数只要被ref修饰，参数就会改变
        public static void change(ref int s1,ref int s2)
        {
            int temp = s1;
            s1 = s2;
            s2 = temp;
        }

        public static void tom(ref string name)
        {
           Console.WriteLine(  name = name + "ojbk");
        }
    }
}

------------------------------------------------------------------------------------------------------------------------

关于params的知识

//应该就是被params修饰的参数来说，params的内容就可以随意更改但是类型要一致。
//看例子2：test的里面的int数组，被params修饰，自己可以随意添加整型的数是多少。不再固定。
//值得一提的是：但是这个要放在方法的最后面 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace params可变参数
{
    class Program
    {
        static void Main(string[] args)
        {
            //int[] num = {66,99,55,44, };
            //Test("老王",num);
            //Test("老王",55,55,55,9999); //从方法哪里的参数可以知道，老王后面应该是数组，但是数组的内容一旦确定就不能修改了
           // 但是要想改变数组的内容，要在方法里加上一个params可变参数（但是可变内容的类型要与数组类型相同），但是这个要放在方法的最后面，
            //应该就是被params修饰的参数来说，params的内容就可以随意更改但是类型要一致。
            //看例子2：test的里面的int数组，被params修饰，自己可以随意添加整型的数是多少。不再固定。
            //值得一提的是：但是这个要放在方法的最后面
           //  例如要添加一个学号
            //Console.ReadKey();
            int b = Sum(56, 56, 56, 56,45);//这里的Sum方法里面的参数被params修饰，那么，里面的数可以随意增减，但必须得是整形
            Console.WriteLine(b);
            Console.ReadKey();
        }
        public static void Test(string name, params int[] score)
        {
            int sum = 0;

            for (int i = 0; i < score.Length; i++)
            {
                sum += score[i];
            }
            Console.WriteLine("我叫{0}，我这次的总成绩{1}", name, sum);

        }
         public static int Sum(params int[] sum)
            {
                int a = 0;
                for (int i = 0; i < sum.Length; i++)
                {
                    a+=sum[i];
                }
                return a;
                //Console.WriteLine();

            }
    }
}

Coding Change The  World  Coding Change The  World   Coding Change The  World  Coding Change The  World Coding Change The  World

总而言之：

out 将方法内的被修饰参数值带出去

ref   将带进入到方法里的值改变后再带出去，无视return的存在

params 主函数内可以对被修饰的参数进行毫无人道的增减

//这里的role参数被out修饰，role 进入到CheckAccount方法里，
//但是可以看到CheckAccount返回的是bool值，但是role的值还是会改变，出了方法后，
//role的值会根据CheekAccount的逻辑改变，然后从方法里带出来，这就是Out的好处。

 public IActionResult Get(string userName, string pwd)
        {
            if (CheckAccount(userName, pwd, out string role))
            {
               Const.ValidAudience = userName + pwd + DateTime.Now.ToString();
               var claims = new[]
                {
                    new Claim(JwtRegisteredClaimNames.Nbf,$"{new DateTimeOffset(DateTime.Now).ToUnixTimeSeconds()}") ,
                    new Claim (JwtRegisteredClaimNames.Exp,$"{new DateTimeOffset(DateTime.Now.AddMinutes(30)).ToUnixTimeSeconds()}"),
                    new Claim(ClaimTypes.NameIdentifier, userName),
                    new Claim("Role", role)
                };
                var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(Const.SecurityKey));
                var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);
                var token = new JwtSecurityToken(
                    //颁发者
                    issuer: Const.Domain,
                    //接收者
                    audience: Const.ValidAudience,
                    //过期时间
                    expires: DateTime.Now.AddMinutes(30),
                    //签名证书
                    signingCredentials: creds,
                    //自定义参数
                    claims: claims
                    );
                return Ok(new
                {
                    token = new JwtSecurityTokenHandler().WriteToken(token)
                });
            }
            else
            {
                return BadRequest(new { message = "username or password is incorrect." });
            }
        }

 private bool CheckAccount(string userName, string pwd, out string role)
        {
            role = "user";

            if (string.IsNullOrEmpty(userName))
                return false;

            if (userName.Equals("admin"))
                role = "admin";

            return true;
        }

 int zz ;
 string e = get("a", "b", out zz);

当我们将Out用于方法内部的时候，只是需要将out修饰的zz,在方法外声明一下就行了，赋不赋值都无所谓，
因为out修饰的一定要在方法内赋值的。
然后出了方法zz的值就变了；
 public static string get(string a,string b,out int c)
 {
    c = 1;
    c = c + 100;
    return a + b;
 }

感觉更多的用法还是TryParse这个上面

关于什么时候用OUT

out表示参数是传出的。一般是用作函数返回多个值时使用。

例如：Int32的TryParse函数，它用作把一个对象转化为Int32类型。

string s = "123";
Int32 a;
bool canParse = Int32.TryParse(s, out a);

Console.WriteLine("canParse的值是"+canParse);//true
Console.WriteLine("a的值是" + a);//123
Console.ReadKey();

也就是说TryParse实际有2个返回值，一个在canParse里，是一个bool值，表示是否能够转换。

另一个返回值在a里，如果能转换，a就是转换后的结果。

也就是说可以用来实验一个参数是不是你要的类型；比如前端传过来一个字符串，你不知道他是不是时间类型，就可以用Out来比较，

  

DateTime mydate;
if (!DateTime.TryParse(myset.Tables[0].Rows[0]["z"].ToString(), out mydate))//备注：如果符合这个时间类型的话，那么mydate的值就是前面取出来的值
{
    Exception ex = new Exception("wnd.attribute8 = [" + myset.Tables[0].Rows[0]["z"].ToString() + "]，无法转换为DateTime类型");
    throw ex;
}

TryParse(a,b)的用法就是将a类型转成b类型； 上面就是判断从数据库中取出来的数据判断是否满足验证要求。

DateTime date;
bool b = DateTime.TryParse("2020/7/23", out date);//这个结果就是b是true，因为'2020/7/23'  符合时间类型的格式；而且date的值也变成了2020/7/23
//bool bb= DateTime.TryParse("123", out date);//这个123没办法转成时间格式，bb就是false，而date还是0:00:00 的样式