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

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

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

0. 目录 2. .NET Test 2.1 测试题目

基础语法练习

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

基础对象练习

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

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

新建接口类，定义属性、方法
新建抽象类，定义字段、属性、普通方法、虚方法、抽象方法
新建A类继承接口，实现其所有成员
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();
}

定义一个集合，类型为时间类型。要求集合内容为从今天开始按索引加一天 (累加的天数为10天)，日期

按降序排序。新建控制台应用程序输出刚刚的集合到前台并格式化日期为（2019-xx-xx），判断如果日

期day为偶数，则通过报错的方法输出到控制台上，并不影响接下去的输出。错误内容为：当天为偶数

位，日期2019-xx-xx

要求：集合的产生过程必须通过程序，排序、判断日期是否为偶数必须用LINQ

public static void DatetimeControl()
{
            //定义一个集合，类型为时间类型
    List dateTimes = new List();

    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"));
            }
        }
    }
}

分别生成斐波那契数列的第40个元素、第48个元素
方法1-栈方法

public static void Fibonacci_Stack(long num)
{
	Stack stack = new Stack();

    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));
}

生成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;
}

新建接口类，定义属性、方法

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();
    }
}

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

.Net相关栏目本月热门文章