.NET-.NET基础(练习检测)

Bertha 。 2022-12-24 05:00 123阅读 0赞

### .NET..NET基础.练习检测.职业技能 ###

*  0. 目录
 *  2. .NET Test
 *   *  2.1 测试题目
     *  2.2 测试解答

# 0. 目录 #

# 2. .NET Test #

## 2.1 测试题目 ##

> 基础语法练习

1.  使用C\#语法实现冒泡排序输出到控制台上。  
    排序内容：var doubleList = new double\[\] \{ 20.3, 11.4, 33.1, 45.2, 50.1, 60.5 \};

> 基础对象练习

1.  定义一个集合，类型为时间类型。要求集合内容为从今天开始按索引加一天 (累加的天数为10天)，日期  
    按降序排序。新建控制台应用程序输出刚刚的集合到前台并格式化日期为（2019-xx-xx），判断如果日  
    期day为偶数，则通过报错的方法输出到控制台上，并不影响接下去的输出。错误内容为：当天为偶数  
    位，日期2019-xx-xx  
    要求：集合的产生过程必须通过程序，排序、判断日期是否为偶数 必须用LINQ
2.  分别生成斐波那契数列的第40个元素、第48个元素
3.  生成10个含数字字母的随机字符串

> 接口、抽象类、继承、多态的综合运用

1.  新建接口类，定义属性、方法
2.  新建抽象类，定义字段、属性、普通方法、虚方法、抽象方法
3.  新建A类继承接口，实现其所有成员
4.  B类继承A类，重写A类的方法

## 2.2 测试解答 ##

*  使用C\#语法实现冒泡排序输出到控制台上。
    
    排序内容：var doubleList = new double\[\] \{ 20.3, 11.4, 33.1, 45.2, 50.1, 60.5 \};
    
        public override void StartSort()
        {
        
            bool flag;
            for (int i = 0; i < SortArrayData.Length; i++)
            {
                flag = false;
                for (int j = SortArrayData.Length - 1; j > i; j--)
                {
                    if (SortArrayData[j - 1] > SortArrayData[j])
                    {
                        Replace(j - 1, j);
                        flag = true;
                    }
                }
                   
                if (flag == false)
                {
                    break;
                }
            }
                
            PrintDate(SortArrayData);
        }
        
        public void Replace(int num1, int num2)
        {
            double temp = SortArrayData[num1];
                SortArrayData[num1] = SortArrayData[num2];
                SortArrayData[num2] = temp; 
        }
            
        public override void PrintDate(double[] sortArrayData)
        {
            for (int i = 0; i < sortArrayData.Length; i++)
            {
                Console.Write(sortArrayData[i] + " ");
            }
        
            Console.WriteLine();
        }

![在这里插入图片描述][20201126214233694.png_pic_center]

*  定义一个集合，类型为时间类型。要求集合内容为从今天开始按索引加一天 (累加的天数为10天)，日期
    
    按降序排序。新建控制台应用程序输出刚刚的集合到前台并格式化日期为（2019-xx-xx），判断如果日
    
    期day为偶数，则通过报错的方法输出到控制台上，并不影响接下去的输出。错误内容为：当天为偶数
    
    位，日期2019-xx-xx
    
    要求：集合的产生过程必须通过程序，排序、判断日期是否为偶数 必须用LINQ
    
        public static void DatetimeControl()
        {
                    //定义一个集合，类型为时间类型
            List<DateTime> dateTimes = new List<DateTime>();
        
            DateTime today = DateTime.Now;
        
            //要求集合内容为从今天开始按索引加一天 (累加的天数为10天)
            for (int i = 1; i <= 10; i++)
            {
            	dateTimes.Add(today.AddDays(i));            }
        
        		//日期按降序排序
                var newlist = from p in dateTimes orderby p descending select p;
        
                //新建控制台应用程序输出刚刚的集合到前台并格式化日期为（2019-xx-xx）
                foreach (var date in newlist)
                {
                    Console.WriteLine(date.ToString("yyyy-MM-dd"));
                }
        
        		//判断如果日期day为偶数，则通过报错的方法输出到控制台上，并不影响接下去的输出
                foreach (var date in newlist)
                {
                	try
                    {
                        if (date.Day % 2 == 0)
                        {
                        	throw new Exception();
                        }
                    }
                    catch (Exception)
                    {
                        Console.WriteLine("当天为偶数位,日期" + date.ToString("yyyy-MM-dd"));
                    }
                }
            }
        }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQ3MzIyOA_size_16_color_FFFFFF_t_70_pic_center]

*  分别生成斐波那契数列的第40个元素、第48个元素  
    `方法1-栈方法`
    
        public static void Fibonacci_Stack(long num)
        {
        	Stack<long> stack = new Stack<long>();
        
            stack.Push(0);
            stack.Push(1);
        
        	for (int i = 0; i < num - 1; i++)
            {
            	long f2 = stack.Pop();
                long f1 = stack.Pop();
                long next = f1 + f2;
        
                stack.Push(f1);
                stack.Push(f2);
                stack.Push(next);
            }
        
                Console.WriteLine(stack.Pop());
        }
    
    `方法2-递归方法`
    
        public static void Fibonacci_Recursion(long num)
        {
        	Console.WriteLine(GetFibonacciSequence(num));
        }
        
        private static long GetFibonacciSequence(long value)
        {
        	if (value == 0 || value == 1)
            {
            	return 1;
            }
            
            return (GetFibonacciSequence(value - 1) + GetFibonacciSequence(value - 2));
        }

![在这里插入图片描述][2020112621430474.png_pic_center]

*  生成10个含数字字母的随机字符串  
    `GUID方法`
    
        public static void GenerateRandomString()
        {
            for (int i = 0; i < 10; i++)
            {
                 var guid = Guid.NewGuid().ToString("N");
                 Console.WriteLine(guid.Substring(0, 9));
            }
        }
    
    `随机种子`
    
        public static void GenerateRandomStringForSeed()
        {
            string randomString = string.Empty;
        
            for (int i = 0; i < 10 ; i++)
            {
                for (int j=0 ; j<10;j++)
                {
                    randomString += RandomSeed();
                }
                Console.WriteLine(randomString);
                randomString = null;
            }
        }
        
        public static string RandomSeed()
        {
        	Random random = new Random(Guid.NewGuid().GetHashCode());
            int dice = random.Next(0,3);
        
        	string color = string.Empty;
        	
            switch (dice)
            {
            	case 0://数字
                {
                	color = ((char)random.Next(48, 58)).ToString();
                    break;
                }
                case 1://大写字母
                {
                	color = ((char)random.Next(65, 91)).ToString();
                    break;
                }
                case 2://小写字母
                {
                	color = ((char)random.Next(97, 123)).ToString();
                    break;
                }
            }
        
        	return color;
        }

![在这里插入图片描述][20201126214320987.png_pic_center]

*  新建接口类，定义属性、方法
    
        interface I_Sort
        {
        	string Sort_Category { get; set; }
        
            void StartSort();
        }
 *  新建抽象类，定义字段、属性、普通方法、虚方法、抽象方法
    
        public abstract class Sort: I_Sort
        {
        	private string sortCategory;
            private int sortnum;
            private double[] sortArrayData;
        
            public Sort()
            {
        
            }
        
        	public Sort(int sortnum)
            {
            	this.sortnum = sortnum;
            }
        
            public Sort(double[] sortArrayData)
            {
                this.sortArrayData = sortArrayData;
            }
        
            public int SortNum
            {
                get
                {
                    return this.sortnum;
                }
                set
                {
                    this.sortnum = value;
                }
            }
        
            public double[] SortArrayData
            {
                get
                {
                    return this.sortArrayData;
                }
                set
                {
                    this.sortArrayData = value;
                }
            }
            
            public string Sort_Category { 
            	get 
            	{
            		return sortCategory;
            	}
            	set 
           		{
            		sortCategory = value;
           		} 
        	}
        
        	public Sort(int sortNum,double[] sortArrayData)
        	{
        		SortNum = sortNum;
            	SortArrayData = sortArrayData;
        	}
        
        	public virtual void StartSort()
        	{
        
        	}
        
        	public abstract void PrintDate(double[] sortArrayData);
        }
 *  新建A类继承接口，实现其所有成员
    
        public abstract class Sort: I_Sort
        {
        	private string sortCategory;
            private int sortnum;
            private double[] sortArrayData;
        
            public Sort()
            {
        
            }
        
        	public Sort(int sortnum)
            {
            	this.sortnum = sortnum;
            }
        
            public Sort(double[] sortArrayData)
            {
                this.sortArrayData = sortArrayData;
            }
        
            public int SortNum
            {
                get
                {
                    return this.sortnum;
                }
                set
                {
                    this.sortnum = value;
                }
            }
        
            public double[] SortArrayData
            {
                get
                {
                    return this.sortArrayData;
                }
                set
                {
                    this.sortArrayData = value;
                }
            }
            
            public string Sort_Category { 
            	get 
            	{
            		return sortCategory;
            	}
            	set 
           		{
            		sortCategory = value;
           		} 
        	}
        
        	public Sort(int sortNum,double[] sortArrayData)
        	{
        		SortNum = sortNum;
            	SortArrayData = sortArrayData;
        	}
        
        	public virtual void StartSort()
        	{
        
        	}
        
        	public abstract void PrintDate(double[] sortArrayData);
        }
 *  B类继承A类，重写A类的方法
    
        public class BubbleSort : Sort, I_Replace
        {
            double[] SortArrayData;
            tring Replace_category = string.Empty;
        
            public BubbleSort(double[] sortArrayData) :
               base(sortArrayData)
            {
                this.SortArrayData = sortArrayData;
            }
        
            public string Replace_Category
            {
                get
                {
                    return Replace_category;
                }
        
        		set
                {
                    this.Replace_category = value;
                }
            }
              
            public override void StartSort()
            {
        
                bool flag;
                for (int i = 0; i < SortArrayData.Length; i++)
                {
                	flag = false;
                    for (int j = SortArrayData.Length - 1; j > i; j--)
                    {
                        if (SortArrayData[j - 1] > SortArrayData[j])
                        {
                            Replace(j - 1, j);
                            flag = true;
                        }
                    }
        
        			if (flag == false)
                    {
                        break;
                    }
                }
        
                PrintDate(SortArrayData);
            }
        
        	public void Replace(int num1, int num2)
            {
            	double temp = SortArrayData[num1];
                SortArrayData[num1] = SortArrayData[num2];
                SortArrayData[num2] = temp; 
            }
        
            public override void PrintDate(double[] sortArrayData)
            {
                for (int i = 0; i < sortArrayData.Length; i++)
                {
                    Console.Write(sortArrayData[i] + " ");
                }
        
        		Console.WriteLine();
            }
        }

[20201126214233694.png_pic_center]: /images/20221120/8e7bac54dc714c9cad5dfb8c6a64e4b8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQ3MzIyOA_size_16_color_FFFFFF_t_70_pic_center]: /images/20221120/bac0c929f0494ac4afe4c5c515693661.png
[2020112621430474.png_pic_center]: https://img-blog.csdnimg.cn/2020112621430474.png#pic_center
[20201126214320987.png_pic_center]: https://img-blog.csdnimg.cn/20201126214320987.png#pic_center