算法收集

最新推荐文章于 2024-05-05 20:37:09 发布

流程管理

最新推荐文章于 2024-05-05 20:37:09 发布

阅读量810

点赞数

分类专栏： C# 数据库文章标签：算法 null class header string textbox

数据库同时被 2 个专栏收录

46 篇文章 0 订阅

订阅专栏

30 篇文章 0 订阅

订阅专栏

冒泡排序 bubble sorting

int t;

int[] a ={21,56,64,94,97,123};

for(int j =a.Length-1;j>0;j--)

{ for(int i =0;i<j;i++)

{ if(a[i]>a[i+1])

{ t =a[i];

a[i]=a[i+1];

a[i+1]=t;

} } }

for(int u =0;u<a.Length;u++)

Console.WriteLine(a[u]); 结果:21,56,64,94,97,123

同时找最大最小

int temp;

int[] a={56,66,5,1230,87,95};

for(int i =0;i<(a.Length+1)/2;i++)

{ if(a[i]>a[a.Length-1-i])

{ temp =a[i];

a[i] =a[a.Length-1-i];

a[a.Length-1-i] =temp;

}

int max =a[a.Length-1],min =a[0];

for(int i=0;i<(a.Length+1)/2;i++)

{ if(min>a[i])

min =a[i];

}

for(int i =(a.Length+1)/2;i<a.Length;i++)

{ if(max<a[i])

max =a[i];

}

Console.WriteLine("{0},{1}",min,max); 结果： 5,1230

基数排序

int [] a={1,5,9,7};

int[] b=new int[10];

for(int i=0;i<a.Length;i++)

b[a[i]]=1;

for(int j=0;j<b.Length;j++)

if(b[j]==1)

Console.WriteLine(j); 结果：1,5,7,9

插入排序

int [] r={12,2,6,65,42};

for (int i=1;i<r.Length;i++)

{ int t;

t=r[i];

int j;

for(j=i-1;j>=0 && r[j]>t;j--)

{}

for(int k=i;k>j+1;k--)

r[k]=r[k-1];

r[j+1]=t;

}

for(int f=0;f<r.Length;f++)

Console.WriteLine(r[f]); 结果：2,6,12,42,65

QuickSort 快速排序

static void QuickSort(int[] a,int start,int end)

{ int i=start,j=end;

int pivot = a[i];

while(i<j)

{ while(i<j && pivot<=a[j])

j--;

a[i] = a[j];

while(i<j && a[i]<=pivot)

i++;

a[j]=a[i];

}

a[i] = pivot;

if(i>start)

QuickSort(a,start,i);

if(i<end)

QuickSort(a,i+1,end);

}

static void Main(string[] args)

{ int[] x={87,56,5,13,5,12,};

QuickSort(x,0,x.Length-1);

for(int i=0;i<x.Length;i++)

Console.WriteLine(x[i]);

} 结果：5,5,12,13,56,87

MergeSort 归并排序

static void MergeSort(int[] a,int s,int e)

{ if(s>=e) return;

MergeSort(a,s,(s+e)/2);

MergeSort(a,(s+e)/2+1,e);

Merge(a,s,(s+e)/2,e);

}

static void Merge(int[] a,int s,int mid, int e)

{ int[] b=new int[a.Length];

for(int w=0;w<a.Length;w++)

b[w]=a[w];

int i=s;

int j=mid+1;

int k=s;

while(i<=mid && j<=e)

{ if(b[i]<b[j])

a[k++] = b[i++];

else

a[k++] = b[j++];

}

while(i<=mid)

a[k++] = b[i++];

while(j<=e)

a[k++] = b[j++];

}

static void Main(string[] args)

{ int[] a={34,2,5,66,87,99};

MergeSort(a,0,a.Length-1);

for(int i=0;i<a.Length;i++)

Console.WriteLine(a[i]);

} 结果:2,5,34,66,87,99

二叉查找树

// 二叉查找树节点 Binary search tree node

public class BinarySearchTreeNode

{ public int key;// 二叉查找树节点的值

public BinarySearchTreeNode left;// 二叉查找树节点的左子节点

public BinarySearchTreeNode right;// 二叉查找树节点的右子节点

/// 二叉查找树节点构造函数

public BinarySearchTreeNode(int nodeValue)

{ key = nodeValue;//nodeValue 节点的值

left = null; right = null;

}

/// 插入节点

public void InsertNode(BinarySearchTreeNode node)

{ if(node.key > this.key)

{ if(this.right == null)

{ this.right = node;//node 插入的节点

return;

}

else

this.right.InsertNode(node);

}

else

{ if(this.left == null)

{ this.left = node; return; }

else

this.left.InsertNode(node);

}

/// 二叉查找树查询

public bool SearchKey(int searchValue)

{ if(this.key == searchValue)//searchValue 需要查询的值

return true;// 是否找到查询的值

if(searchValue > this.key)

{ if(this.right == null) return false;

else

return this.right.SearchKey(searchValue);

}

else

{ if(this.left == null) return false;

else

return this.left.SearchKey(searchValue);

}

// 中序遍历

public void MiddleDisplay()

{ if(this.left != null)

this.left.MiddleDisplay();

Console.WriteLine(this.key);

if(this.right != null)

this.right.MiddleDisplay();

}

// 前序遍历

public void FrontDisplay()

{ Console.WriteLine(this.key);

if(this.left != null)

this.left.FrontDisplay();

if(this.right != null)

this.right.FrontDisplay();

}

// 后序遍历

public void BehindDisplay()

{ if(this.left != null)

this.left.BehindDisplay();

if(this.right != null)

this.right.BehindDisplay();

Console.WriteLine(this.key);

}

/// 二叉查找树

public class BinarySearchTree

{ private BinarySearchTreeNode root;

/// 生成一个二叉查找树

public BinarySearchTree()

{ root = nul; }

/// 生成一个二叉查找树

///<param name="nodeValue"> 二叉查找树根节点的值 </param>

public BinarySearchTree(int nodeValue)

{ root = new BinarySearchTreeNode(nodeValue); }

/// 在二叉查找树上插入一个节点

///<param name="nodeValue"> 插入节点的值 </param>

public void InsertBinarySearchTreeNode(int nodeValue)

{ BinarySearchTreeNode insertNode = new BinarySearchTreeNode(nodeValue);

if(root == null)

{ root = insertNode;

return;

}

else

root.InsertNode(insertNode);

return;

}

/// 在二叉查找树上查询一个数

///<param name="searchValue"> 需要查询的值 </param>

///<returns> 是否找到查询的值 </returns>

public bool SearchKey(int searchValue)

{ if(root.key == searchValue) return true;

else

return root.SearchKey(searchValue);

}

/// 二叉查找树中序遍历

public void MiddleDisplay()

{ root.MiddeleDisplay(); return; }

/// 二叉查找树前序遍历

public void FrontDisplay()

{ root.FrontDisplay(); return; }

/// 二叉查找树后序遍历

public void BehindDisplay()

{ root.BehindDisplay(); return; }

/// 二叉查找树排序

///<param name="a"> 需要排序的数组 </param>

public static void BinarySearchTreeSort(int [] a)

{ BinarySearchTree t = new BinarySearchTree();

for(int i = 0; i < a.Length; i ++)

t.InsertBinarySearchTreeNode(a[i]);

t.MiddleDisplay();return;

}/// 二叉查找树查找

///<param name="a"> 进行查找的数组 </param>

///<param name="searchKey"> 需要查找的树 </param>

public static bool BinarySearchTreeSearch(int [] a, int searchKey)

{ BinarySearchTree t = new BinarySearchTree();

for(int i = 0; i < a.Length; i ++)

t.InsertBinarySearchTreeNode(a[i]);

return t.SearchKey(searchKey);

}

namespace 二叉树

{ class Node

{ int n;

public Node(int x)

{ n=x; }

public Node Left;

public Node Right;

public void Insert(Node node)

{ if(node.n > this.n)

{ if(this.Right == null)

this.Right = node;

else

this.Right.Insert(node); }

else

{ if(this.Left == null)

{ this.Left = node; }

else

{ this.Left.Insert(node); } } } // 递归

public void Show()

{ Console.WriteLine(n); } }

class BinaryTree

{ Node root;

public void GenerateTree(Node node) // 高内聚，低耦合

{ if(root == null)

{ root = node; return; }// 如果树是空，第一次加节点

root.Insert(node);

}

public void ShowInOrder(Node node) // 中序遍历(in order)：左中右。先(前)序遍历(pre order)：中左右。后序遍历(post order)：左右中。

{ if(node == null) return;// 递归必须有个终止条件,递归方法中一定要接受参数

ShowInOrder(node.Left);

node.Show();

ShowInOrder(node.Right);

}

public void Show()

{ ShowInOrder(root); }

}

class A

{ static void Main()

{ BinaryTree b = new BinaryTree();

Node node = new Node(5);

b.GenerateTree(node);

node = new Node(13);

b.GenerateTree(node);

node = new Node(6);

b.GenerateTree(node);

node = new Node(26);

b.GenerateTree(node);

node = new Node(7);

b.GenerateTree(node);

b.Show(); } } } 结果 :5,6,7,13,26

单链表

class Node

{ int a;

public Node(int a)

{ this.a=a; }

public int A

{get{return a;} set{a=value;} }

public Node next;

}

class LinkedList

{ Node header;

public void Generate(int x)

{ if(header==null)

header=new Node(x);

else

{ Node n = new Node(x);

if(n.A < header.A)

{ n.next = header;

header=n;

return;

}

Node tmp=header;

Node t=header;

while(tmp.A < n.A)

{ t=tmp; // 为了下一次循环

tmp=tmp.next;

if(tmp==null)

break;

}

t.next=n;

n.next=tmp;

}

public void Out()

{ Node tmp=header;

while(tmp!=null)

{ Console.WriteLine(tmp.A);

tmp = tmp.next;

} } }

class Test

{ static void Main()

{ LinkedList ll = new LinkedList();

ll.Generate(6);

ll.Generate(36);

ll.Generate(26);

ll.Generate(16);

ll.Out();

} } }

反向链表

class Link //this class reverse the LinkedList

{ public int a;

public Link next;

}

class createLink //the class create the LinkedList

{

Link header=null;

Link p = null;

Link temp = null;

Link l=null; //Link k=null;

Link g=null;

public void create()

{ string str;

int i;

Console.WriteLine("Please enter number:");

str=Console.ReadLine();

while(str!="y")

{ i=Convert.ToInt32(str);

temp=new Link();

temp.a=i;

temp.next=null;

if(g==null)

g=temp;

if(header==null)

header=temp;

if(p==null)

p=temp;

else

{ p.next=temp;

p=p.next;

}

Console.WriteLine("please enter number:");

str=Console.ReadLine();

}

public void display()

{ while(header!=null)

{ Console.WriteLine(header.a);

header=header.next;

}

public void reversed() // the mothod reversed the LinkedList

{ Link k=null;

Link tmp=null;

Link com =null;

if(tmp==null)

tmp=header.next;

while(tmp!=null)

{ // if(com==null)

// com=header;

l=tmp;

if(k==null)

{ header.next=null;

k=header;

}

com=header;

header=l;

tmp=l.next;

l.next=com;

}

public void show()

{ while(l!=null)

{ Console.WriteLine(l.a);

l=l.next;

} } }

class Tester

{ static void Main()

{ createLink cl=new createLink();

cl.create();

//cl.display();

cl.reversed();

cl.show();

} } }

Stack 栈

class Node

{ int a;

public Node(int a)

{ this.a=a; }

public int A

{ get{return a;} set{a=value;} }

public Node next;

}

class LinkedList

{ protected Node header;

public void Generate(int x)

{ if(header==null)

header=new Node(x);

else

{ Node n = new Node(x);

n.next=header;

header=n;

}

public void Out()

{ Node tmp=header;

while(tmp!=null)

{ Console.WriteLine(tmp.A);

tmp = tmp.next;

} } }

class Stack : LinkedList

{ public void Push(int x)

{ this.Generate(x); }

public int Pop()

{ if(this.header == null)

return -1; // empty stack

int n = header.A;

header = header.next;

return n;

}

class Test

{ static void Main()

{ Stack ss = new Stack();

ss.Push(7);

ss.Push(78);

ss.Push(9);

ss.Push(2);

int i = ss.Pop();

while(i != -1)

{ Console.WriteLine(i);

i = ss.Pop();

} } } }

C# 基础

ArrayList

ArrayList al;

al =new ArrayList();

string s = Console.ReadLine();

while(s !="q")

{ al.Add(s);

s = Console.ReadLine();

}

for(int i=0;i<al.Count;i++)

Console.WriteLine(al[i].ToString());

从键盘输入一个数组,并求最大

int [] a;

Console.WriteLine("Pls input len:");

int len = Convert.ToInt32(Console.ReadLine());

a = new int[len];

Console.WriteLine("Pls input array");

for(int i=0;i<len;i++)

{ a[i]=Convert.ToInt32(Console.ReadLine()); }

for(int j=0;j<a.Length;j++)

Console.WriteLine(a[j]);

for(int k=0;k<a.Length;k++)

{ if(a[0]<a[k])

a[0]=a[k];

} Console.WriteLine(a[0]);

递归

int fac (int n)

{ if(n==0) return 1;

return n*fac(n-1);

}

斐波那契数列第n项

int fib (int n)

{ if(n==1) return 1;

if(n==2) return 1;

return fib(n-1)+fib(n-2);

}

递归求1加到100

public int Fac(int n)

{ if(n==1) return 1;

return n+Fac(n-1);

}

static void Main()

{ math f=new math();

int s=f.Fac(100);

Console.WriteLine(s);

}

求前24项斐波那契序列数

static int fib(int n)

{ if(n==1) return 1;

if(n==2) return 1;

return fib(n-1)+fib(n-2);

}

static void Main(string[] args)

{ int t=0;

for(int i=1;i<25;i++)

{ t=fib(i);

Console.WriteLine(t);

} }

汉诺塔

static void Hanoi(string X, string Y,string Z,int n)

{ if(n==1)

{ Console.WriteLine(X + "-->" +Z);

return;

}

Hanoi (X,Z,Y,n-1);

Console.WriteLine(X+"-->"+Z); 三

Hanoi (Y,X,Z,n-1);

}

static void Main(string[] args)

{ Hanoi("A","B","C",5); }

3 位的水仙花数

for(int i=100;i<1000;i++)

{ int a=i/100; int c=i%10; int b=((i-c)/10)%10;

if(i==a*a*a+b*b*b+c*c*c)

Console.WriteLine(i);

}

StringBuilder

class A

{ static void Main()

{ StringBuilder a=new StringBuilder();

a.Append ("asa");

a.Append ("www");

string s=a.ToString();

Console.WriteLine(s);

}

} 结果:asawww

singleton 设计模式

class A

{ private int v;

A(int x)

{ v=x; }

public int V

{ get{return v;} }

static A c=null;

public static A fun(int n)

{ if(c==null)

c=new A(n);

return c;

}

class B

{ static void Main(string[] args)

{ A c=A.fun(2);

Console.WriteLine(c.V);

c=A.fun(8);

Console.WriteLine(c.V);

}

} 结果：2,2

多线程：

using System;

using System.Threading;

namespace SingleTon

{ class A

{ static readonly object padlock = new object();

string s;

private A(string x)

{ s=x; }

static A a=null;

public static A GetA(string s)

{

lock(padlock)

{

if(a==null)

{

Random rd = new Random(unchecked((int)DateTime.Now.Ticks));

int v =rd.Next(10, 1000);

Thread.Sleep(v);

a = new A(s);

}

return a;

}

public override string ToString ()

{ return s; }

}

class B

{

A a=null;

public void Test1()

{

a = A.GetA("Morning!");

Console.WriteLine(a.ToString ());

}

public void Test2()

{

a = A.GetA("Afternoon!");

Console.WriteLine(a.ToString());

}

class T

{

static void Main()

{

B b = new B();

Thread t1=new Thread(new ThreadStart(b.Test1));

Thread t2=new Thread(new ThreadStart(b.Test2));

t1.Start();

t2.Start();

}

运算符的重载

class A

{ int x;

public int X

{ get { return x; }

set { x=value; }

}

public static A operator +(A a,A b)

{ A c=new A();

c.x=a.x+b.x;

return c;

}

class B

{ static void Main()

{ A a=new A();

a.X=3;

A b=new A();

b.X=5;

A c=a+b;

Console.WriteLine(c.X);

}

} 结果:8

++-- 重载

class A

{ public int val;

public static A operator ++ (A a)

{ A x=new A();

x.val = a.val;

x.val++;

return x;

}

public static A operator -- (A a)

{ A x=new A();

x.val=a.val;

x.val--;

return x;

}

class text

{ static void Main()

{ A a=new A();

a.val=10;

A b=a--;

Console.WriteLine(b.val);

Console.WriteLine(a.val);

a.val=10;

A c=--a;

Console.WriteLine(c.val);

Console.WriteLine(a.val);

a.val=10;

A y=a++;

Console.WriteLine(y.val);

Console.WriteLine(a.val);

a.val=10;

A z=++a;

Console.WriteLine(z.val);

Console.WriteLine(a.val);

}

} 结果:10,9,9,9 10,11,11,11

装箱拆箱

class Test

{ static void Main()

{ int i=9;

object o=i;

int j=(int)o;

Console.WriteLine(j);

}

反转字符

string aa="huajian";

System.Text.StringBuilder sb=new System.Text.StringBuilder();

for (int i=0;i<aa.Length;i++)

{ sb.Append (aa.Substring (aa.Length -1-i,1)); }

Console .WriteLine (sb); 结果:naijauh

多态和抽象类

1 、实现多态：

1 ）、在基类中定义虚方法 ( 在方法前用 virtual 关键字修饰 )

2 ）、在派生类中重写基类的虚方法（在方法前用 override 关键字修饰）

3 ）、用派生类对象实例化基类对象

4 ）、用基类对象调用方法

结果是：调用派生类的重写方法

示例：

class A

{ public virtual void aa() //1 、基类中定义虚方法

{ Console.WriteLine("Aaa"); }

}

class B:A

{ public override void aa()//2 、派生类中定义虚方法

{ Console.WriteLine("Baa"); }

static void Main(string[] args)

{ A test=new B();//3 、用派生类对象实例化基类对象

test.aa(); //4 、用基类对象调用方法

}

} 结果执行派生类中的方法： Baa

2 、抽象基类

1 ）、语法：定义类前加 abstract 修饰符修饰，例： abstract class A{}

2 ）、抽象方法：只有方法的声明，没有方法的实现，例： public abstract void d();

3 ）、抽象类中可以只含有抽象方法或只含有已实现的方法或抽象方法和已实现的方法都有。

4 ）、抽象类不能实例化对象。

5 ）、继承抽象类的派生类中必须实现抽象类的抽象方法。方法用 override 修饰。

例：

using System;

abstract class A // 抽象基类

{ public abstract void aa();// 抽象方法

public void dis()

{ Console.WriteLine("A"); }

}

class B:A

{ public override void aa() // 派生类中实现抽象方法

{ Console.WriteLine("B"); }

static void Main(string[] args)

{ B test=new B();

test.aa();// 实现基类的抽象方法

test.dis();// 继承基类的方法

}

} 结果： B , A

事件和事件处理程序

• 在面向对象理论中，一个对象（类的实例）可以有属性（property，获取或设置对象的状态）、方法（method，对象可以做的动作）等成员外，还有事件（ event ）。所谓事件，是对象内部状态发生了某些变化、或者对象做某些动作时（或做之前、做之后），向外界发出的通知。打个比方就是，对象“张三”肚子疼了，然后他站在空地上大叫一声“我肚子疼了！” 事件就是这个通知。

• 那么，相对于对象内部发出的事件通知，外部环境可能需要应对某些事件的发生，而做出相应的反应。接着上面的比方，张三大叫一声之后，救护车来了把它接到医院（或者疯人院，呵呵，开个玩笑）。外界因应事件发生而做出的反应（具体到程序上，就是针对该事件而写的那些处理代码），称为事件处理程序（ event handler ）。

• 事件处理程序必须和对象的事件挂钩后，才可能会被执行。否则，孤立的事件处理程序不会被执行。另一方面，对象发生事件时，并不一定要有相应的处理程序。就如张三大叫之后，外界环境没有做出任何反应。也就是说，对象的事件和外界对该对象的事件处理之间，并没有必然的联系，需要你去挂接。

• 我希望大家首先区分“ 事件”和“ 事件处理程序”这两个概念。事件是隶属于对象（类）本身的，事件处理程序是外界代码针对对象的事件做出的反应。事件，是对象（类）的设计者、开发者应该完成的；事件处理程序是外界调用方需要完成的。简单的说，事件是“内”；事件处理程序是“外”。

例：btnOne.Click += new EventHandler(Button.click);

btnTwo.Click += new EventHandler(Button.click) ;

.NET

.NET 的技术优势

• 多语言的集成开发，可以适应不同技术特点的人．

• 对ＸＭＬ的全面支持，可以实现不同系统之间的数据共享

• 多方位的客户体验，可以更容易的让客户接受．

• 与数据库的高度集成，实现快速的数据存取．

• 已创建的框架模型，可以实现高效的开发速度．

• 编译执行的运行机制，加快了客户的浏览速度．

• 完善的认证模式，适应了用户不同要求的网络安全系数．

• 与以前技术的全面兼容，降低了客户的开发费用．

• 良好的向后兼容性，适应了未来技术的发展 .

面向对象的思想与技术

• 所谓面向对象，就是把现实世间的所有物体对象化。可以是一个人，一匹马等等。

• 而我个人认为面向对象，首先要把面向与对象分开，在我们明确了对象之后，才可以考虑如何去面对他，而面对他并不是指你的脸面对向他，而是指我们如何去挖掘这个对象的实际的内涵。比如我们把一个人确定为对象，那么我们就应该考虑这个人具有什么样的外表特征．也就是我们所说的一个对象的属性．具体对人来说：指他的身高、体重、姓名、年龄等等；往往指那些静态的特征。

• 我们还应该考虑这个对象在特定的环境下会有什么样的反映或者是这个对象本身具有什么样的行为。既我们所说的方法(函数)；具体对一个人来说：指人的吃，走，笑，遇到惊吓所表现出来的哭等等；往往指那些动态的行为。

• 而我们把那些具有相同的属性和行为的对象分为一个一个不同的集合．我们把那些不同的集合换个说法称为不同的类．类其实就是一个高度的抽象与概括。

• 而大千世间，从远古到今天，事物都在不断的发展、不断地进化、或者是不断的退化。举例来说：在古代，我们的祖先猿类在经历了数万年的进化而演变为今天的人类。也就是说人类是由猿类进化而来。等同于说人类继承至猿类。经过时间的冲洗而发展起来的。那么我们要问：猿类与人类的区别是什么？也就是说，怎么样才能区分他们两者。答案是：通过他们两者之间不同的特征、生活方式、动作行为加以区分归类的。

• 而我们给不同的类别定义其特有的属性、行为的过程就称为封装。封装的主要思想就是把一些特有的属性与方法赋予一个具有相同特征与行为的类的过程。

• 更加仔细的同学会发现现实世间中的每一个物体都不是完全一样的．比如不同的人 (既我们所说的对象)有不同的笑容，或者是不同的走路姿势。这样的现象我们概括起来就是：同样的事情(方法)对于不同的物体(对象)有着不同的表现或处理方式.我们称这样的现象为面向对象的多态。

• 多态的主要思想就是：同样的一件事情，有着不同的处理方式 (动态多态)或表现形式(静态多态)。

• 基于现实世间的事物表现原理，而架构自己运行机制的一种技术称为面向对象的技术。也就是说一种技术他是以面向的对象为设计理念的。而.NET就是众多面向对象技术的一种最优秀的技术。

• 具体表现为： .NET中所有的变量、属性、方法都应该放在类里边。一切皆为类。而由类创造对象，对象调用其相应的成员方法与成员变量。成员方法可以使用其内部的成员变量。

• 类就是具有相同属性和共同行为的对象的集合。

• 对象就是类的具体表现形式。

• 封装对于一个类内部的结构而言的。什么样的方法可以被调用，什么样的变量可以被访问。

• 继承对于两个有着某些牵连的类而言的。一个类是另一个的扩充。或者是细化。

• 多态对于两个不同的类或是同一个类的不同对象而言的。同样的方法对于不同的类有不同的实现 (overwrite)；同样的方法对与同样的类有不同的版本(overload)。

ASP.Net

第三方控件

• 所谓第三方控件就是完全由我们自己写的控件。

• 第三方控件包括两种类型的控件 :单一的控件和组合控件。

• 单一的第三方控件需要继承 :System.Web.UI.WebControls.label(textBox)

• 组合的第三方控件需要继承 :System.Web.UI.WebControls.WebControl

ASP.Net 的缓存技术

缓存技术是 ASP.Net所特有的，分三种：

1) 页面缓存。整个页面都保存起来，以后访问直接读取 dll文件。

2) 部分页面缓存。指缓存一个 user control。

3) 数据缓存。

页面跳转命令

1) Response.Redirect 参数可以是任意一个网站的任意页面。

2) Server.Transfer 位于本网站或站点的其他页面。

3) Server.Execute 本站点的页面。

方法 2与3的区别是Transfer从页面1转到页面2后，控制执行权就转给页面2。Execute从页面1转到页面2后，控制执行权就转给页面2。页面2执行完后，执行权又转回页面2。

方法 1的优点是可以跨越网站，缺点是效率低，因为有两个来回。

方法 2：页面转到Page2，但URL还是Page1，因为页面跳转发生在Server端，不是在Client端。

身份认证

1) Windows

2) Forms

3) Passport

Web Application 的5个内置对象： Response,Request,Server,Application,Session

State Management 状态管理（控件的数据（属性）的管理）

1. Server端管理（大多数用此管理）

1) Session 基于会话，私有的。

2) Application 全局的，多线程的，任何会话都可读写它。

3) Cache

2. Client端管理

1) Query String 可以保存一些数据，只能放简单数据类型。

Page 1中： Response.Redirect(“Webform2.aspx?a=”+TextBox1.Text);

Page 2中： TextBox1.Text = Request.QueryString;

2) Cookies 保存在 Client端。

Page 1中： HttpCookie c = new HttpCookie(“b”,TextBox1.Text); //b是Cookies的名字

Response.Cookies.Add(c);

//Cookies里的数据随 Response数据包返回Server端。

Page 2中： TextBox1.Text = Request.Cookies[“b”].Value.ToString();

3) 隐藏字段（只在本页面工作）

4) ViewState（与 Session语法一样）

注： 3，4不能跨越页面。

ADO.Net ADO.Net 是一项在.Net上操纵数据的技术。

连接字符串

String str=System.Configuration.ConfigurationSettings.AppSettings["constr"].ToString();

</appSettings> // 本地server可以是点(.)或local。

连接数据库

String str=System.Configuration.ConfigurationSettings.AppSettings["constr"].ToString();

SqlConnection con = new SqlConnection(str);

SqlCommand com = new SqlCommand();

com.Connection = con; // 或者SqlCommand com=new SqlCommand("Get",con);

com.CommandText ="Get";

com.CommandType=CommandType.StoredProcedure;

删除表中state为空的项

DataSet ds = (DataSet) Session["author"];

DataTable dt = ds.Tables["qq"];

ArrayList al = new ArrayList();

foreach(DataRow dr in dt.Rows)

{ if(dr["state"] is System.DBNull)

al.Add(dr);

}

for(int i=0; i<al.Count; i++)

((DataRow)al[i]).Delete(); // 这只是删除了页面的值，如要修改DB中相应的值，需要下面的提交

this.DataGrid1.DataSource=dt; // 确定数据源

this.DataGrid1.DataBind(); // 这一行不能少，绑定数据源

// 注意is的用法,如果dr["state"]是System.DBNull类型,结果就是true。DB里值为null的在ASP.Net里的类型为System.DBNull。

File Manage 中的

Directory di = new Directory(@“C:/”);

di.GetDirectories(); // 读取di(也就是C:/)下的所有子目录

di.GetFiles(); // 读取di下所有文件

FileInfo fi = new FileInfo(@ “C:/q.txt”); //fi代表q.txt这个文件

PlaceHolder 占位符，动态添加控件用。

Button1_Click

{ TextBox tb = new TextBox();

tb.Text="cc";

tb.Width=80;

tb.ID="tb";

this.PlaceHolder1.Controls.Add(tb);

}

找出页面上所有内容为空的Lable

Button1.Click

{

foreach(Control c in this.Control[1].Controls)

{

if(c.GetType() == typeof(Lable)) // 找出数据类型是Lable的控件

if(((Lable)c).Text == “” ) // 找出Text为空的Lable控件

((Lable)c).Text = “ hello ” ;

}// 变量c的内容不能改，因为它是只读的。

}

注：typeof，把一个数据类型转换成系统承认的数据类型。

页面的所有控件都在this.Control[1].Controls里, Control[1]对应于Html的form。

非面向连接的ADO.Net（Disconnect）

1. 客户端一次从数据库读过来数据（只针对查询）。

1) 查询的结果保存在客户端的 memory中。

2）所有服务器资源被释放。（断开连接）

2. 客户端可以修改离线数据。

3. 当客户端修改数据结束后，重新连接数据库并提交结果。数据被修改的表一定要有主键。

非面向连接的优点

1. 单个数据库可以同时支持多个用户。

2. 对数据的操作更快更灵活（因为在客户端对数据进行操作）。

3. 数据没有绑定到连接（使用于 n层结构）。

4. 非常适合 WebApplication和n层架构。

Disconnect 方式需要哪些类？

1. Connection、 Command，与面向连接一样。

2. DataSet，用来存放数据。

3. DataAdapter，把数据从数据库搬运到客户端，控制与数据库的连接和关闭。

注： DataReader一条一条读，DataAdapter一次全部读过来。

Disconnect 代码

private void Page_Load(object sender, System.EventArgs e)

{

String str = System.Configuration.ConfigurationSettings.AppSettings["constr"].ToString();

SqlConnection con = new SqlConnection(str);

SqlCommand com = new SqlCommand();

com.Connection = con;

com.CommandText = "GetAuthors";

com.CommandType = CommandType.StoredProcedure;

SqlDataAdapter da = new SqlDataAdapter();

da.SelectCommand = com;

// SqlCommandBuilder ,command 命令自动生成器。

SqlCommandBuilder cb = new SqlCommandBuilder();

da.InsertCommand = cb.GetInsertCommand();

da.UpdateCommand = cb.GetUpdateCommand();

da.DeleteCommand = cb.GetDeleteCommand();

DataSet ds = (DataSet)Session["author"];

DataTable dt = ds.Tables["qq"];

con.Open();// 不显示连接，不能打开一个事务。

SqlTransaction tr = con.BeginTransaction();

da.InsertCommand.Transaction = tr;

da.UpdateCommand.Transaction = tr;

da.DeleteCommand.Transaction = tr;

try

{

da.Update(dt);

tr.Commit();

Response.Write("<script language=javascript>alert('no error occurred')</script>");

}

catch

{

tr.Rollback();

Response.Write("<script language=javascript>alert('error occurred')</script>");

}

finally

{

con.Close();

}

DataGrid 的分页

DataGrid1_PageIndexChanged()

{

this.DataGrid1.CurrentPageIndex = e.NewPageIndex;

DataSet ds = (DataSet)Session["ds"];

this.DataGrid1.DataSource = ds.Tables[0];

this.DataGrid1.DataBind();

}

C# 创建Table

DataTable dt = new DataTable("mytable");

DataColumn dc1 = new DataColumn("id", typeof(int));

dt.Columns.Add(dc1);

DataColumn dc2 = new DataColumn("name", typeof(string));

dt.Columns.Add(dc2);

DataColumn dc3 = new DataColumn("phone", typeof(string));

dt.Columns.Add(dc3);

DataRow dr = dt.NewRow();

dr["id"]=7;

dr["name"]="wang";

dr["phone"]="576876787";

dt.Rows.Add(dr);

dr = dt.NewRow();

dr["id"]=8;

dr["name"]="uuwang";

dr["phone"]="589h876787";

dt.Rows.Add(dr);

dr = dt.NewRow();

dr["id"]=67;

dr["name"]="jhwang";

dr["phone"]="5jjk76876787";

dt.Rows.Add(dr);

dr = dt.NewRow();

dr["id"]=76;

dr["name"]="9890809wang";

dr["phone"]="576876bjhjkhki787";

dt.Rows.Add(dr);

this.DataGrid1.DataSource=dt.DefaultView;

this.DataGrid1.DataBind();

1. 简述 private、 protected、 public、 internal 修饰符的访问权限。
答：private :   私有成员, 在类的内部才可以访问。
     protected : 保护成员，该类内部和继承类中可以访问。
     public :    公共成员，完全公开，没有访问限制。
     internal:   在同一命名空间内可以访问。

2. 一列数的规则如下: 1、1、2、3、5、8、13、21、34...... 求第30位数是多少，用递归算法实现。
答：public class MainClass
    {
        public static void Main()
        {
            Console.WriteLine(Foo(30));
        }
        public static int Foo(int i)
        {
            if (i <= 0)
                return 0;
            else if(i > 0 && i <= 2)
                return 1;
            else return Foo(i -1) + Foo(i - 2);
        }
    }

3.C#中的委托是什么？事件是不是一种委托？
答：
委托可以把一个方法作为参数代入另一个方法。
委托可以理解为指向一个函数的引用。
事件，是一种特殊的委托

4.请编程遍历页面上所有TextBox控件并给它赋值为string.Empty？
答：
      foreach (System.Windows.Forms.Control control in this.Controls)
      {
     if (control is System.Windows.Forms.TextBox)
        {
            System.Windows.Forms.TextBox tb =          (System.Windows.Forms.TextBox)control ;
            tb.Text = String.Empty ;
         }
      }

5.求以下表达式的值，写出您想到的一种或几种实现方法： 1-2+3-4+……+m
答：
    int Num = this.TextBox1.Text.ToString() ;
int Sum = 0 ;
for (int i = 0 ; i < Num + 1 ; i++)
{
  if((i%2) == 1)
  {
   Sum += i ;
  }
  else
  {
   Sum = Sum - I ;
  }
}
System.Console.WriteLine(Sum.ToString());

6.用.net做B/S结构的系统，您是用几层结构来开发，每一层之间的关系以及为什么要这样分层？
答：一般为3层
数据访问层，业务层，表示层。
数据访问层对数据库进行增删查改。
业务层一般分为二层，业务表观层实现与表示层的沟通，业务规则层实现用户密码的安全等。
表示层为了与用户交互例如用户添加表单。
优点：分工明确，条理清晰，易于调试，而且具有可扩展性。
缺点：增加成本。

7.SQLSERVER服务器中，给定表 table1 中有两个字段 ID、LastUpdateDate，ID表示更新的事务号， LastUpdateDate表示更新时的服务器时间，请使用一句SQL语句获得最后更新的事务号
答：Select ID FROM table1 Where LastUpdateDate = (Select MAX(LastUpdateDate) FROM table1)

8.写出一条Sql语句：取出表A中第31到第40记录（SQLServer,以自动增长的ID作为主键,注意：ID可能不是连续的。
答：解1: select top 10 * from A where id not in (select top 30 id from A)
解2: select top 10 * from A where id > (select max(id) from (select top 30 id from A )as A)

9.GC是什么? 为什么要有GC?
答：GC是垃圾收集器。程序员不用担心内存管理，因为垃圾收集器会自动进行管理。要请求垃圾收集，可以调用下面的方法之一：
System.gc()
Runtime.getRuntime().gc()

10.String s = new String("xyz");创建了几个String Object?
答：两个对象，一个是“xyx”,一个是指向“xyx”的引用对象s。

11.abstract class和interface有什么区别?
答：
声明方法的存在而不去实现它的类被叫做抽象类（abstract class），它用于要创建一个体现某些基本行为的类，并为该类声明方法，但不能在该类中实现该类的情况。不能创建abstract 类的实例。然而可以创建一个变量，其类型是一个抽象类，并让它指向具体子类的一个实例。不能有抽象构造函数或抽象静态方法。Abstract 类的子类为它们父类中的所有抽象方法提供实现，否则它们也是抽象类为。取而代之，在子类中实现该方法。知道其行为的其它类可以在类中实现这些方法。
接口（interface）是抽象类的变体。在接口中，所有方法都是抽象的。多继承性可通过实现这样的接口而获得。接口中的所有方法都是抽象的，没有一个有程序体。接口只可以定义static final成员变量。接口的实现与子类相似，除了该实现类不能从接口定义中继承行为。当类实现特殊接口时，它定义（即将程序体给予）所有这种接口的方法。然后，它可以在实现了该接口的类的任何对象上调用接口的方法。由于有抽象类，它允许使用接口名作为引用变量的类型。通常的动态联编将生效。引用可以转换到接口类型或从接口类型转换，instanceof 运算符可以用来决定某对象的类是否实现了接口。

12.启动一个线程是用run()还是start()?
答：启动一个线程是调用start()方法，使线程所代表的虚拟处理机处于可运行状态，这意味着它可以由JVM调度并执行。这并不意味着线程就会立即运行。run()方法可以产生必须退出的标志来停止一个线程。

13.接口是否可继承接口? 抽象类是否可实现(implements)接口? 抽象类是否可继承实体类(concrete class)?
答：接口可以继承接口。抽象类可以实现(implements)接口，抽象类是否可继承实体类，但前提是实体类必须有明确的构造函数。

14.构造器Constructor是否可被override?
答：构造器Constructor不能被继承，因此不能重写Overriding，但可以被重载Overloading。

15.是否可以继承String类?
答：String类是final类故不可以继承。

16.try {}里有一个return语句，那么紧跟在这个try后的finally {}里的code会不会被执行，什么时候被执行，在return前还是后?
答：会执行，在return前执行。

17.sleep() 和 wait() 有什么区别?
答：sleep()方法是使线程停止一段时间的方法。在sleep 时间间隔期满后，线程不一定立即恢复执行。这是因为在那个时刻，其它线程可能正在运行而且没有被调度为放弃执行，除非(a)“醒来”的线程具有更高的优先级
(b)正在运行的线程因为其它原因而阻塞。
wait()是线程交互时，如果线程对一个同步对象x 发出一个wait()调用，该线程会暂停执行，被调对象进入等待状态，直到被唤醒或等待时间到。

18.short s1 = 1; s1 = s1 + 1;有什么错? short s1 = 1; s1 += 1;有什么错?
答：short s1 = 1; s1 = s1 + 1;有错，s1是short型，s1+1是int型,不能显式转化为short型。可修改为s1 =(short)(s1 + 1) 。short s1 = 1; s1 += 1正确。

19.Session有什么重大BUG，微软提出了什么方法加以解决？
答：是iis中由于有进程回收机制，系统繁忙的话Session会丢失，可以用Sate server或SQL Server数据库的方式存储Session。不过这种方式比较慢，而且无法捕获Session的END事件。

20.ASP。NET与ASP相比，主要有哪些进步？
答：asp解释形，aspx编译型，性能提高，有利于保护源码。

21.产生一个int数组，长度为100，并向其中随机插入1-100，并且不能重复。
int[] intArr=new int[100];
ArrayList myList=new ArrayList();
Random rnd=new Random();
while(myList.Count<100)
{
int num=rnd.Next(1,101);
if(!myList.Contains(num))
myList.Add(num);
}
for(int i=0;i<100;i++)
intArr[i]=(int)myList[i];

22.什么是Web Service？UDDI？
答：Web Service便是基于网络的、分布式的模块化组件，它执行特定的任务，遵守具体的技术规范，这些规范使得Web Service能与其他兼容的组件进行互操作。
　 UDDI 的目的是为电子商务建立标准；UDDI是一套基于Web的、分布式的、为Web Service提供的、信息注册中心的实现标准规范，同时也包含一组使企业能将自身提供的Web Service注册，以使别的企业能够发现的访问协议的实现标准。

23.什么是code-Behind技术。
答：ASPX,RESX和CS三个后缀的文件，这个就是代码分离.实现了HTML代码和服务器代码分离.方便代码编写和整理.

24.什么是SOAP,有哪些应用。
答：simple object access protocal,简单对象接受协议.以xml为基本编码结构,建立在已有通信协议上(如http,不过据说ms在搞最底层的架构在tcp/ip上的soap)的一种规范Web Service使用的协议..

25.C#中 property 与 attribute的区别，他们各有什么用处，这种机制的好处在哪里？
答：一个是属性，用于存取类的字段，一个是特性，用来标识类，方法等的附加性质

26.net的错误处理机制是什么？
答：.net错误处理机制采用try->catch->finally结构，发生错误时，层层上抛，直到找到匹配的Catch为止。

27.在.net（C# or vb.net）中如何用户自定义消息，并在窗体中处理这些消息。
答：在form中重载DefWndProc函数来处理消息:
protected override void DefWndProc ( ref System.WinForms.Message m )
{
switch(m.msg)
{
    case WM_Lbutton :
　 ///string与MFC中的CString的Format函数的使用方法有所不同
　 string message = string.Format("收到消息!参数为:{0},{1}",m.wParam,m.lParam);
　 MessageBox.Show(message);///显示一个消息框
　 break;
    case USER:
    处理的代码
    default:
　 base.DefWndProc(ref m);///调用基类函数处理非自定义消息。
　 break;
}
}

28.在.net（C# or vb.net）中如何取消一个窗体的关闭。
答：private void Form1_Closing(object sender, System.ComponentModel.CancelEventArgs e)
   {
      e.Cancel=true;
   }

29.在.net（C# or vb.net）中，Appplication.Exit 还是 Form.Close有什么不同？
答：一个是退出整个应用程序，一个是关闭其中一个form。

30.在C#中有一个double型的变量，比如10321.5，比如122235401.21644，作为货币的值如何按各个不同国家的习惯来输出。比如美国用$10,321.50和$122，235，401.22而在英国则为￡10 321.50和￡122 235 401.22
答：System.Globalization.CultureInfo MyCulture = new System.Globalization.CultureInfo("en-US");
    //System.Globalization.CultureInfo MyCulture = new System.Globalization.CultureInfo("en-GB");为英    国货币类型
    decimal y = 9999999999999999999999999999m;
    string str = String.Format(MyCulture,"My amount = {0:c}",y);

31.C#可否对内存进行直接的操作？
答：在.net下，.net引用了垃圾回收（GC）功能，它替代了程序员不过在C#中，不能直接实现Finalize方法，而是在析构函数中调用基类的Finalize()方法

32.ADO。NET相对于ADO等主要有什么改进？
答：1:ado.net不依赖于ole db提供程序,而是使用.net托管提供的程序,2:不使用com3:不在支持动态游标和服务器端游 4:,可以断开connection而保留当前数据集可用 5:强类型转换

33.大概描述一下ASP。NET服务器控件的生命周期
答：初始化加载视图状态处理回发数据加载发送回发更改通知处理回发事件预呈现保存状态呈现处置卸载

34.Static Nested Class 和 Inner Class的不同，说得越多越好
答：Static Nested Class是被声明为静态（static）的内部类，它可以不依赖于外部类实例被实例化。而通常的内部类需要在外部类实例化后才能实例化。

35.& 和 && 的区别
& 是位运算符，表示按位与运算， && 是逻辑运算符，表示逻辑与（ and ）。

36.error和exception有什么区别?
答：error 表示恢复不是不可能但很困难的情况下的一种严重问题。比如说内存溢出。不可能指望程序能处理这样的情况。
exception 表示一种设计或实现问题。也就是说，它表示如果程序运行正常，从不会发生的情况。

37.<%# %> 和 <% %> 有什么区别？
答：<%# %>表示绑定的数据源，<% %>是服务器端代码块。

38.下面的例子中

using System;
     class A
     {
          public static int X;
          static A(){
               X=B.Y+1;
          }
      }
      class B
      {
           public static int Y=A.X+1;
           static B(){}
           static void Main(){
                Console.WriteLine("X={0},Y={1}",A.X,B.Y);
           }
       }
产生的输出结果是什么？    答：x=1,y=2

SQL

1：找出公司里收入最高的前三名员工：

SQL> select rownum, last_name, salary from (select last_name, salary from s_emp order by salary desc) where rownum<=3;

2：找出表中的某一行或某几行的数据：

（ 1）：找出表中第三行数据：

用以下方法是不行的，因为 rownum后面只可以用<或<=号,不可以用=,>号和其它的比较符号。

SQL> select * from s_emp where rownum=3; no rows selected

SQL> select * from s_emp where rownum between 3 and 5; no rows selected

正确的方法如下：

SQL>select last_name, salary from (select rownum a, b.* from s_emp b) * where a=3

（ 2）：找出第三行到第五行之间的数据：

SQL>select last_name, salary from (select rownum a, b.* from s_emp b) * where a between 3 and 5

3：找出那些工资高于他们所在部门的平均工资的员工。

（ 1）：第一种方法：

SQL> select last_name, dept_id, salary from s_emp a where salary>(select avg(salary) from s_emp where dept_id=a.dept_id); 10 rows selected.

（ 2）：第二种方法：

SQL>select a.last_name, a.salary, a.dept_id, b.avgsal from s_emp a, (select dept_id, avg(salary) avgsal from s_emp group by dept_id) b where a.dept_id=b.dept_id * and a.salary>b.avgsal

10 rows selected.

4：找出那些工资高于他们所在部门的 manager的工资的员工。

SQL>select id, last_name, salary, manager_id from s_emp a where salary>(select salary from s_emp where id=a.manager_id) 10 rows selected.

流程管理

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
算法收集

冒泡排序 bubble sorting int t; int[] a ={21,56,64,94,97,123}; for(int j =a.Length-1;j>0;j--) { for(int i =0;i { if(a[i]>a[i+1])
复制链接

扫一扫

专栏目录

算法收集

“相关推荐”对你有帮助么？