asp.net面试题收集

1.new有几种用法
 第一种:new Class();
 第二种:覆盖方法
public new XXXX(){}
 第三种:new 约束指定泛型类声明中的任何类型参数都必须有公共的无参数构造函数。

2.如何把一个array复制到arrayList里

foreach( object o in array )arrayList.Add(o);

3.datagrid.datasouse可以连接什么数据源 [dataset,datatable,dataview]

dataset,datatable,dataview , IList

4.概述反射和序列化

反射:程序集包含模块，而模块包含类型，类型又包含成员。反射则提供了封装程序集、模块和类型的对象。您可以使用反射动态地创建类型的实例，将类型绑定到现有对象，或从现有对象中获取类型。然后，可以调用类型的方法或访问其字段和属性

序列化:序列化是将对象转换为容易传输的格式的过程。例如，可以序列化一个对象，然后使用 HTTP 通过 Internet 在客户端和服务器之间传输该对象。在另一端，反序列化将从该流重新构造对象。

5.概述o/r mapping 的原理

利用反射，配置 将类于数据库表映射

6.类成员有( )种可访问形式

可访问形式？不懂。

可访问性：public ,protected ,private,internal

7.用sealed修饰的类有什么特点

sealed 修饰符用于防止从所修饰的类派生出其它类。如果一个密封类被指定为其他类的基类，则会发生编译时错误。

密封类不能同时为抽象类。

sealed 修饰符主要用于防止非有意的派生，但是它还能促使某些运行时优化。具体说来，由于密封类永远不会有任何派生类，所以对密封类的实例的虚拟函数成员的调用可以转换为非虚拟调用来处理。

8.列举ADO.NET中的五个主要对象，并简单描述

connection,command,dataReader,trans,dataset ...

9.执行下面代码后：

String strTemp ="abcdefg 某某某"；
Int i System.Text.Encoding.Default.GetBytes(strTemp).Length;
Int j = strTemp.Length;
问：i=(14 ) ；j=(11 )

i=(14 ) ；j=(11 ) 中文两个字节

10.C#中，string str = null 与 string str =""，请尽量用文字说明区别。(要点：说明详细的内存空间分配)

string str ="" 分配空间

11.详述.NET里class和struct的异同！

class:放在 ? struct放在？
struct值传递

类与结构有很多相似之处：结构可以实现接口，并且可以具有与类相同的成员类型。然而，结构在几个重要方面不同于类：结构为值类型而不是引用类型，并且结构不支持继承。结构的值存储在“在堆栈上”或“内联”。细心的程序员有时可以通过聪明地使用结构来增强性能。

12.概述.NET里对 remoting 和 webservice 两项技术的理解和实际中的应用。

远程逻辑调用，remoing接口只能用在.net中

13.什么是code-behind技术

aspx and cs

14.概述三层结构体系
web/business/dataaccess

15.asp.net如何实现MVC模式，举例说明！
web/business/dataaccess

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

1.面向对象的思想主要包括什么？
答:这个题范围太广,不知道说什么.

2.什么是ASP.net中的用户控件
答:用户控件就是.ascx扩展名的东西喽,可以拖到不同的页面中调用,以节省代码.比如登陆可能在多个页面上有,就可以做成用户控件,但是有一个问题就是用户控件拖到不同级别的目录下后里面的图片等的相对路径会变得不准确,需要自已写方法调整.

3.什么叫应用程序域？什么是受管制的代码？什么是强类型系统？什么是装箱和拆箱？什么是重载？CTS、CLS和CLR分别作何解释？
答:装箱就是把值类型转成引用类型,从MS IL角度看好像是boxing,没记错的话是把值从堆栈转到堆中.拆箱相反,重载就是指一个方法名同,参数个数不同,返回值可以相同的方法.CLR是通用语言运行时,其它的不清楚.

4.列举一下你所了解的XML技术及其应用
答:XML可是好东西,保存配置,站与站之间的交流,WEB SERVICE都要用它.

5.值类型和引用类型的区别？写出C#的样例代码。
答:结构是值类型,类是引用类型,所以传结构就是值类型的应用啦,传对象或类就是引用类型的,这个不用多写了吧.

6.ADO.net中常用的对象有哪些？分别描述一下。
答:connection command sqladapter dataset datatable dataview等等.写不完了.

7.如何理解委托？
答:据说相当于函数指针,定义了委托就可以在不调用原方法名称的情况下调用那个方法.
msdn2005中是这样解释的:

委托具有以下特点：
委托类似于 C++ 函数指针，但它是类型安全的。
委托允许将方法作为参数进行传递。
委托可用于定义回调方法。
委托可以链接在一起；例如，可以对一个事件调用多个方法。
方法不需要与委托签名精确匹配。有关更多信息，请参见协变和逆变。
C# 2.0 版引入了匿名方法的概念，此类方法允许将代码块作为参数传递，以代替单独定义的方法。

8.C#中的接口和类有什么异同。
答:这个异同可多了,要说清楚还真不容易.

9.。net中读写数据库需要用到哪些类？他们的作用
答:这个类自已可以写的啊,你是指基类吗?那configuration,sqlconnection,sqlcommand等都要用到.

10.UDP连接和TCP连接的异同。
答:前者只管传,不管数据到不到,无须建立连接.后者保证传输的数据准确,须要连结.

11.ASP.net的身份验证方式有哪些？分别是什么原理？
答:form认证,windows集成认证等,原理不清楚.

12.进程和线程分别怎么理解？
答:进程是老子,线程是儿子,没有老子就没有儿子,一个老子可以有多个儿子.一个儿子可以成为别人的儿子,一个老子也可以为别的老子生儿子.

13.什么是code-Behind技术。
答:代码分离,这是个明智的东西,像ASP这样混成一堆很不爽.或者可以理解成HTML代码写在前台,C#代码写在后台.当然前台也有脚本,类的调用等,其实写在一起也是可以的.

14.活动目录的作用。
答:这个不明白.请明白的补充一下.

15..net中读写XML的类都归属于哪些命名空间？
答:System.Xml
我自已写的就不一定了,嘿嘿.

16.解释一下UDDI、WSDL的意义及其作用。
答:什么东西?

17.什么是SOAP,有哪些应用。
答:SOAP（Simple Object Access Protocol ）简单对象访问协议是在分散或分布式的环境中交换信息并执行远程过程调用的协议，是一个基于XML的协议。使用SOAP，不用考虑任何特定的传输协议（最常用的还是HTTP协议），可以允许任何类型的对象或代码，在任何平台上，以任何一直语言相互通信。这种相互通信采用的是XML格式的消息,具体请看:http://playist.blogchina.com/2521621.html

18.如何部署一个ASP.net页面。
答:随便啦,想直接上传就直接上传,想打包成EXE就打包,看个人喜好.

19.如何理解.net中的垃圾回收机制。
答:GC?对象创建了总要清除啊,不然内存哪够用?

20.常用的调用webservice方法有哪些？
答:调用就调用,还有很多方法吗?

- 作者： 契永保 2006年04月28日, 星期五 15:14　 回复（0） |　 引用（0） 加入博采

 危险字符过滤最新完善版的类 现在要想要在url中限制输入：
1、SQL注入类的字符串，如：exec、select、……；
2、SQL注入类的特殊字符，如：'、……；
3、限制输入html和script文本，如：<script ……>，<iframe ……>；
4、不友好字符或限制词语，如：他X的、……；

这四种过滤在这个类中都处理了，但就是不知道如何调用哦。请指示一下咯。谢谢。

using System;
using System.IO;
using System.Text;
using System.Text.RegularExpressions;
using System.Runtime.Remoting;
using System.Runtime.Remoting.Proxies;
using System.Runtime.Remoting.Messaging;
using System.Reflection;

namespace FilterRealProxy
{
 /// <summary>
 ///  FilterRealProxy类：一个真实代理, 拦截它所代理对象中方法的返回值，并对需要过滤的返回值进行过滤。
 /// </summary>
 public class FilterRealProxy:RealProxy
 {
  private MarshalByRefObject target;
  public FilterRealProxy(MarshalByRefObject target):base(target.GetType())
  {
   this.target=target;   
  }
  public override IMessage Invoke(IMessage msg)
  {
   IMethodCallMessage callMsg=msg as IMethodCallMessage;
   IMethodReturnMessage returnMsg = RemotingServices.ExecuteMessage(target,callMsg);
   //检查返回值是否为String,如果不是String,就没必要进行过滤
   if(this.IsMatchType(returnMsg.ReturnValue))
   {
    string returnValue=this.Filter(returnMsg.ReturnValue.ToString(),returnMsg.MethodName);           
    return new ReturnMessage(returnValue,null,0,null,callMsg);
   }
   return returnMsg;
　　　　 }
  protected string Filter(string ReturnValue,string MethodName)
  {
   MethodInfo methodInfo=target.GetType().GetMethod(MethodName);
   object[] attributes=methodInfo.GetCustomAttributes(typeof(StringFilter),true);
   foreach (object attrib in attributes)
   {
    return FilterHandler.Process(((StringFilter)attrib).FilterType,ReturnValue);
   }
   return ReturnValue;
  }
  protected bool IsMatchType(object obj)
  {
   return obj is System.String;
  }
 }
 ///<summary>
 ///  StringFilter类：自定义属性类, 定义目标元素的过滤类型
 ///</summary>
 public class StringFilter:Attribute
 {
  protected FilterType _filterType;
  public StringFilter(FilterType filterType)
  {
   this._filterType=filterType;
  }
  public FilterType FilterType
  {
   get
   {
    return _filterType;
   }
  }
 }
 /// <summary>
 /// 枚举类：用于指定过滤类型，例如：对script过滤还是对html进行过滤？
 /// </summary>
 [Flags()]
 public enum FilterType
 {
  Script = 1,
  Html =2,
  Object=3,
  AHrefScript=4,
  Iframe=5,
  Frameset=6,
  Src=7,
  BadWords=8,
  //Include=9,
  All=16
 }
 ///<summary>
 /// 过滤处理类：根据过滤类型，调用相应的过滤处理方法。
 ///</summary>
 
 public class FilterHandler
 {
  private FilterHandler()
  {
  }
  public static string Process(FilterType filterType,string filterContent)
  {
   switch(filterType)
   {
    case FilterType.Script:
     filterContent=FilterScript(filterContent);
     break;
    case FilterType.Html:
     filterContent=FilterHtml(filterContent);
     break;
    case FilterType.Object:
     filterContent=FilterObject(filterContent);
     break;
    case FilterType.AHrefScript:
     filterContent=FilterAHrefScript(filterContent);
     break;
    case FilterType.Iframe:
     filterContent=FilterIframe(filterContent);
     break;
    case FilterType.Frameset:
     filterContent=FilterFrameset(filterContent);
     break;
    case FilterType.Src:
     filterContent=FilterSrc(filterContent);
     break;
     //case FilterType.Include:
     // filterContent=FilterInclude(filterContent);
     // break;
    case FilterType.BadWords:
     filterContent=FilterBadWords(filterContent);
     break;
    case FilterType.All:
     filterContent=FilterAll(filterContent);
     break;
    default:
     //do nothing
     break;
   }
   return filterContent;
  }

public static string FilterScript(string content)
  {
   string commentPattern = @"(?'comment'<!--.*?--[  ]*>)" ;
   string embeddedScriptComments = @"(/*.*?*/|//.*?[ ])" ;
   string scriptPattern = String.Format(@"(?'script'<[  ]*script[^>]*>(.*?{0}?)*<[  ]*/script[^>]*>)",embeddedScriptComments);
   // 包含注释和Script语句
   string pattern = String.Format(@"(?s)({0}|{1})", commentPattern, scriptPattern) ;
   return StripScriptAttributesFromTags(Regex.Replace(content,pattern,string.Empty,RegexOptions.IgnoreCase));
  }
  private static string StripScriptAttributesFromTags(string content)
  {
   string eventAttribs = @"on(blur|c(hange|lick)|dblclick|focus|keypress|(key|mouse)(down|up)|(un)?load
                    |mouse(move|o(ut|ver))|reset|s(elect|ubmit))" ;
   
   string pattern = String.Format(@"(?inx)
   <(w+)s+
            (
                (?'attribute'
                (?'attributeName'{0})s*=s*
                (?'delim'['""]?)
                (?'attributeValue'[^'"">]+)
                (3)
           )
            |
            (?'attribute'
                (?'attributeName'href)s*=s*
                (?'delim'['""]?)
                (?'attributeValue'javascript[^'"">]+)
                (3)
           )
            |
            [^>]
   )*
   >",eventAttribs);
   Regex re = new Regex(pattern) ;
   // 使用MatchEvaluator的委托
   return re.Replace(content, new MatchEvaluator(StripAttributesHandler)) ;
  }
  private static string StripAttributesHandler(Match m)
  {
   if(m.Groups["attribute"].Success )
   {
    return m.Value.Replace(m.Groups["attribute"].Value, "") ;
   }
   else
   {
    return m.Value ;
   }
  }
  public static string FilterAHrefScript(string content)
  {
   string newstr=FilterScript(content);
   string regexstr=@" href[ ^=]*= *[sS]*script *:";
   return Regex.Replace(newstr,regexstr,string.Empty,RegexOptions.IgnoreCase);
  }
  public static string FilterSrc(string content)
  {
   string newstr=FilterScript(content);
   string regexstr=@" src *= *['""]?[^.]+.(js|vbs|asp|aspx|php|jsp)['""]";
   return Regex.Replace(newstr,regexstr,@"",RegexOptions.IgnoreCase);
  }
  /*
  public static string FilterInclude(string content)
  {
   string newstr=FilterScript(content);
   string regexstr=@"<[sS]*include *(file|virtual) *= *[sS]*.(js|vbs|asp|aspx|php|jsp)[^>]*>";
   return Regex.Replace(newstr,regexstr,string.Empty,RegexOptions.IgnoreCase);
  }
  */
  public static string FilterHtml(string content)
  {
   string newstr=FilterScript(content);
   string regexstr=@"<[^>]*>";
   return Regex.Replace(newstr,regexstr,string.Empty,RegexOptions.IgnoreCase);
  }
  public static string FilterObject(string content)
  {
   string ])*>(w|W)*regexstr=@"(?i)<Object([^>])*>(w|W)*</Object([^>])*>";
   return Regex.Replace(content,regexstr,string.Empty,RegexOptions.IgnoreCase);
  }
  public static string FilterIframe(string content)
  {
   string ])*>(w|W)*regexstr=@"(?i)<Iframe([^>])*>(w|W)*</Iframe([^>])*>";
   return Regex.Replace(content,regexstr,string.Empty,RegexOptions.IgnoreCase);
  }
  public static string FilterFrameset(string content)
  {
   string ])*>(w|W)*regexstr=@"(?i)<Frameset([^>])*>(w|W)*</Frameset([^>])*>";
   return Regex.Replace(content,regexstr,string.Empty,RegexOptions.IgnoreCase);
  }
  //移除非法或不友好字符
  /// <summary>
  /// 移除非法或不友好字符！
  /// </summary>
  private static string FilterBadWords(string chkStr)
  {
   //这里的非法和不友好字符由你任意加，用“|”分隔，支持正则表达式,由于本Blog禁止贴非法和不友好字符，所以这里无法加上。
   string BadWords=@"";
   if (chkStr == "")
   {
    return "";
   }
   string[] bwords = BadWords.Split('#');
   int i,j;
   string str;
   StringBuilder substr = new StringBuilder();
   for(i = 0; i< bwords.Length; i++)
   {
    str=bwords[i].ToString().Trim();
    string regStr,toStr;
    regStr=str;
    Regex r=new Regex(regStr,RegexOptions.IgnoreCase | RegexOptions.Singleline| RegexOptions.Multiline);
    Match m=r.Match(chkStr);
    if(m.Success)
    {
     j=m.Value.Length;
     substr.Insert(0,"*",j);
     toStr=substr.ToString();
     chkStr=Regex.Replace(chkStr,regStr,toStr,RegexOptions.IgnoreCase | RegexOptions.Singleline| RegexOptions.Multiline); 
    }
    substr.Remove(0,substr.Length);
   }
   return chkStr;
  }
  public static string FilterAll(string content)
  {
   content = FilterHtml(content);
   content = FilterScript(content);
   content = FilterAHrefScript(content);
   content = FilterObject(content);
   content = FilterIframe(content);
   content = FilterFrameset(content);
   content = FilterSrc(content);
   content = FilterBadWords(content);
   //content = FilterInclude(content);
   return content;
  }
 }
}