1.【使用EF Code-First格局和Fluent API来啄磨EF中之涉】

针对ASP.NET程序员来说,面试时平常碰到一些技艺问题。本文也而搜集130鸣大的ASP.NET面试题目,供我们参考。

原稿链接:http://www.c-sharpcorner.com/UploadFile/3d39b4/relationship-in-entity-framework-using-code-first-approach-w/

  1. 简述 private、
    protected、 public、
    internal 修饰符的走访权限。
    答 . private : 私有成员, 在类的内部才方可看。 
    protected : 珍重成员,该类内部与继承类中可以看。 
    public : 公共成员,完全公之于世,没有看限制。 
    internal: 在平命名空间内可以拜。

In this
article, you will learn about relationships in Entity Framework using
the Code First Approach with Fluent API.

2 .列举ASP.NET 页面中传递值的几乎种植办法。 
答. 1.使用QueryString, 如….?id=1;
response. Redirect()…. 
2.使用Session变量 
3.使用Server.Transfer

在当下首作品被,你以会面念及下EF
Code-First情势和Fluent
API来研讨EF中之涉及(一对一,一对大多,多针对性多)。

  1. 平等排数的平整如下: 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); 

Introduction【介绍】

A relationship, in the context of databases, is
a situation that exists between two relational database
tables when one table has a foreign
key that references the primary key of the other table. Relationships allow relational databases to
split and store data in various tables, while linking disparate data
items. For example, if we want to store information about
Customerand
his Order, then we need to create
two tables, one for the Customerand another for the Order. Both tables, Customerand Order, will have the relationship one-to-many so
whenever we retrieve all orders of a customer, then we can easily retrieve
them. 

对于涉嫌,在数据库上下文中,是坐如此的情事在:关周密据库中,有点儿独数据库关系表,其中一个表,有一个外键,并且是外键指向另外一个表明底主键。关系允许数据库将数据,分开储存数据及各个不同之表中,这样大家不怕可以方便之询问数据了。例如,假使我们挂念只要存储客户之音讯以及订单音信,那个时刻,大家可创造五只数据表,一个凡是Customer一个凡是Order,这片独表明来一对差不多之涉嫌【一个用户发好有多单订单,一个订单就属一个用户拥有】,所以不管啥时候,我们牵挂使查询一个用户之所有订单音讯,大家尽管得非凡容易的询问及了。

There are
several types of database relationships. In this article, I will cover
the following:

数据库被起几乎种植不同之涉,在当下篇著作被,我拿会称到脚那多少个:

  • One-to-One
    Relationships【一对一涉及】
  • One-to-Many
    or Many to One Relationships【一对多仍然多对同样关系】
  • Many-to-Many
    Relationships【多针对多关系】

Entity
Framework Code First allows us to use our own domain classes to
represent the model that Entity Framework relies on to perform querying,
change tracking and updating functions. The Code First approach follows
conventions over the configuration, but it also gives us two ways to add
a configuration on over classes. One is using simple attributes
called DataAnnotationsand another is using Code First’s Fluent API,
that provides you with a way to describe configuration imperatively, in
code. This article will focus on tuning up the relationship in the
Fluent API.

EF
Code
First情势,允许我们使用好的世界接目前突显模型,然后EF会基于此模型举办询问,跟踪改变,做革新操作分外。这些Code-First格局听从约定大于配置,不过她同样受了我们有限栽艺术,在世界接近及充分配置音讯。其中一个尽管是多少声明,其余一个虽然是下Code-First’s
Fluent API。Fluent API
提供了一致栽为命的点子,来叙述配置。这篇稿子中,我将晤面专注让采取Fluent
API的法门。

To
understand the relationship in the Entity Framework Code First approach,
we create an entity and define their configuration using the Fluent API.
We will create two class library projects, one library project
(EF.Core) has entities and another project (EF.Data) has these
entities configuration with DbContext. We also create a unit test
project (EF.UnitTest) that will be used to test our code. We will use
the following classes that are in a class diagram to explain the
preceding three relationships.

为明白Code-First形式,学习数据库关系,我们成立了一个实体并且动Fluent
API来定义配置新闻,同样,我们用会面创两独类库文件,一个类库文件【EF.Core】放实体,另一个类库【EF.Data】放这么些实体的布置文件,然后,我们还有一个单元测试项目【EF.UnitTest】,用来测试我们写的代码,我们拿会用下图表的好像,来诠释三栽数据库关系。

图片 1

 

As in the
preceding class diagram, the BaseEntityclass is a base class that is
inherited by each other class. Each derived entity represents each
database table. We will use two derived entities combination from the
left side to explain each relationship type and that’s why we create six
entities.

在面的图中,BaseEntity是基类,被所有其他类继承,每一个子类代表一个数据表,我拿会动用图中,每半个实体来解释每种数据库关系,这也是干什么我创立6只子类实体的故。

图片 2

So first
of all, we create the BaseEntityclass that is inherited by each
derived entity under the EF.Coreclass library project.

故此,首先,我们于EF.Core类库项目下,创制以会让此外类似继承的BaseEntity实体类。

图片 3图片 4

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

namespace EF.Core
{
    public class BaseEntity
    {
        /// <summary>
        /// ID
        /// </summary>
        public int ID { get; set; }
        /// <summary>
        /// 添加时间
        /// </summary>
        public DateTime AddedDate { get; set; }
        /// <summary>
        /// 修改时间
        /// </summary>
        public DateTime ModifiedDate { get; set; }
        /// <summary>
        /// IP地址
        /// </summary>
        public string IP { get; set; } 


    }
}

View
Code

We use
navigation properties to access a related entity object from one to
another. The navigation properties provide a way to navigate an
association between two entity types. Every object can have a navigation
property for every relationship in which it participates. Navigation
properties allow you to navigate and manage relationships in both
directions, returning either a reference object (if the multiplicity is
either one or zero-or-one) or a collection (if the multiplicity is
many).

Now let’s
see each relationship one-by-one.

于一个实体中,大家选择导航属性,可以取拿到另外相关联的实业,导航属性提供了一个方法,来连续三只来关联的实业。对于每种关系的实体来说,每一个实体对象可以发一个导航属性。导航属性允许你双向性的导航,并管制实体之间的涉及。要么再次来到一个引用的实业对象【这种状态下之关联是一对一要么零对一】,要么回到一个汇【这种场合下之干是如出一辙对多,或者基本上对几近】。我们来分别看望每种数据库关系吧。

 

4.C#碰到之委托是什么?事件是勿是一样种委托?
答 : 
托可以管一个智作为参数代入另外一个道。
信托可以了然吧对一个函数的援。
大凡,是千篇一律栽特殊的委托

Our Roadmap towards Learning MVC with Entity Framework【我们读MVC和EF的门道】

 

 

5.override以及重载的别
答 :
override
与重载的区别。重载是措施的名号相同。参数或参数类型不同,举办多次重载以适应不同的用
Override 是拓展基类中函数的重写。为了适应需要。

One-to-One Relationship【一对一提到】

 

Both
tables can have only one record on either side of the relationship. Each
primary key value relates to only one record (or no records) in the
related table. Keep in mind that this kind of relationship is not very
common and most one-to-one relationships are forced by business rules
and don’t flow naturally from the data. In the absence of such a rule,
you can usually combine both tables into one table without breaking any
normalization rules.

星星只表明内,只能出于一个笔录在其它一个表中。每一个主键的价值,只可以干到此外一张表的平长长的或者零条记录。请牢记,这多少个一定底涉嫌匪是生的大规模,并且大多数之一定之关联,是商逻辑使然,并且数据也不是当然地。缺乏这样平等修规则,就是当那种涉及下,你可拿简单个表合并也一个阐明,而无打破常规的平整。

 

To understand one-to-one relationships, we
create two entities, one is Userand another is UserProfile. One user
can have a single profile, a Usertable that will have a primary key
and that same key will be both primary and foreign keys for the UserProfiletable. Let’s see Figure 1.2 for one-to-one
relationship.

为知道一对准同样关系,大家创制两独实体,一个凡是User其余一个凡是UserProfile,一个User只有单个Profile,User表将碰面时有发生一个主键,并且是字段将谋面是UserProfile表的主键和外键。我们看下图:

图片 5

Now we
create both entities Userand UserProfilein the EF.Coreproject
under the Data folder. Our Userclass code snippet is as in the
following:

现我们以会面于Data文件夹下,创制多只实体,一个是User实体,此外一个是UserProfile实体。我们的User实体的代码如下:

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

namespace EF.Core.Data
{
   public class User:BaseEntity
    {
       /// <summary>
       /// 用户名
       /// </summary>
       public string UserName { get; set; }

       /// <summary>
       /// 电子邮件
       /// </summary>
       public string Email { get; set; }

       /// <summary>
       /// 密码
       /// </summary>
       public string Password { get; set; }

       /// <summary>
       /// 导航属性--用户详情
       /// </summary>
       public virtual UserProfile UserProfile { get; set; }
    }
}

The UserProfileclass
code snippet is as in the following:

UserProfile实体的代码快如下:

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

namespace EF.Core.Data
{
    /// <summary>
    /// 用户详情实体
    /// </summary>
   public class UserProfile:BaseEntity
    {
       /// <summary>
       /// 姓
       /// </summary>
       public string FirstName { get; set; }

       /// <summary>
       /// 名
       /// </summary>
       public string LastName { get; set; }

       /// <summary>
       /// 地址
       /// </summary>
       public string Address { get; set; }

       /// <summary>
       /// 导航属性--User
       /// </summary>
       public virtual User User { get; set; }
    }
}

As you
can see in the preceding two code snippets, each entity is using another
entity as a navigation property so that you can access the related
object from each other.

就像你看底一模一样,下边的片独片的代码块被,每个实体都选用互相的实体,作为导航属性,由此你得自此外实体中走访此外的实体。

Now, we
define the configuration for both entities that will be used when the
database table will be created by the entity. The configuration defines
another class library project EF.Dataunder the Mapping folder. Now
create two configuration classes for each entity. For the Userentity,
we create the UserMapentity.

今昔,我们拿会吗实体定义配置,这一个布局将会合以,为实体生产数据库关系表的当儿用到。我们将安排写在其它的一个类库中【EF.Data】,在Mapping文件夹下,分别吗每个实体创立布局类似,对于User实体,大家创造UserMap配置实体。

注意:大家设本着EF.Data引入EF。

using EF.Core.Data;
using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations.Schema;
using System.Data.Entity.ModelConfiguration;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace EF.Data.Mapping
{
   public class UserMap:EntityTypeConfiguration<User>
    {
       public UserMap() 
       {
           //配置主键
           this.HasKey(s => s.ID);

           //给ID配置自动增长
           this.Property(s => s.ID).HasDatabaseGeneratedOption(DatabaseGeneratedOption.Identity);
           //配置字段
           this.Property(s => s.UserName).IsRequired().HasColumnType("nvarchar").HasMaxLength(25);
           this.Property(s => s.Email).IsRequired().HasColumnType("nvarchar").HasMaxLength(25);
           this.Property(s => s.AddedDate).IsRequired();
           this.Property(s => s.ModifiedDate).IsRequired();
           this.Property(s => s.IP);

           //配置表
           this.ToTable("User");


       }
    }
}

We will
use the same way to create the configuration for other entities as for
the User.EntityTypeConfigurationis an important class that allows
configuration to be performed for an entity type in a model. This is
done using the modelbuilder in an override of
the OnModelCreatemethod. The constructor of the UserMapclass uses
the Fluent API to map and configure properties in the table. So let’s
see each method used in the constructor one-by-one.

我们以汇合使同一的措施,为此外一个实体UserProfile创立布局类似,EntityTypeConfiguration类,是一个颇重点的好像,它可为一个实体类,配置一个模型。这将谋面通过modelbuilder对象来成功,modelbuilder对象是于重新写方法OnModelCreate中的。UserMap类的构造函数,使用了Fluent
API来照,配置属性。我们来探Usermap 构造函数中的每个方法吧。

  1. HasKey():
    The Haskey()method configures a primary key on table. 【HasKey方法,配置表的主键】
  2. Property():
    The Propertymethod configures attributes for each property
    belonging to an entity or complex type. It is used to obtain a
    configuration object for a given property. The options on the
    configuration object are specific to the type being configured.【Property方法配置每个实体的性能】
  3. HasDatabaseGeneratedOption:
    It configures how values for the property are generated by the
    database.【HasDatabaseGeneratedOption配置属性列是否是自动生成的。】
  4. DatabaseGeneratedOption.IdentityDatabaseGeneratedOptionis
    the database annotation. It enumerates a database generated 【自动生成列配置】option. DatabaseGeneratedOption.Identityis
    used to create an auto-increment column in the table by a unique
    value.
  5. ToTable():
    Configures the table name that this entity type is mapped to.【Totable ,为实体配置表名称】

Now
create the UserProfileconfiguration class,
the UserProfileMapclass.

现行探视UserProfileMap配置类

 

using EF.Core.Data;
using System;
using System.Collections.Generic;
using System.Data.Entity.ModelConfiguration;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace EF.Data.Mapping
{
   public class UserProfileMap:EntityTypeConfiguration<UserProfile>
    {
       public UserProfileMap()
       {
           this.HasKey(s=>s.ID);

           this.Property(s => s.FirstName).IsRequired();
           this.Property(s => s.LastName).IsRequired();
           this.Property(s => s.Address).HasMaxLength(100).HasColumnType("nvarchar").IsRequired();

           this.Property(s => s.AddedDate).IsRequired();
           this.Property(s => s.ModifiedDate).IsRequired();
           this.Property(s => s.IP);

           //配置关系[一个用户只能有一个用户详情!!!]
           this.HasRequired(s => s.User).WithRequiredDependent(s => s.UserProfile);

           this.ToTable("UserProfile"); 

       }
    }
}

 

In the
code snippet above, we defined a one-to-one relationship between
both Userand UserProfilesentities. This relationship is defined by
the Fluent API using
the HasRequired()andWithRequiredDependent()methods so these
methods are as in the following:

当面的代码块被,大家以User和UserProfile实体之间定义了十分的涉及,这些涉及,是通过Fluent
API中之HasRequired方法,和WithRequiredDependent方法来兑现的。

  1. HasRequired():
    Configures a required relationship from this entity type. Instances
    of the entity type will not be able to be saved to the database
    unless this relationship is specified. The foreign key in the
    database will be non-nullable. In other words, UserProfilecan’t
    be saved independently without Userentity.【HasRequired方法,配置了实体的须关系,实体的字段,唯有以众目睽睽指定值的状下,数据才会于允许插入数据库被。数据库被的外键,将会见是未允为空的。换句话说UserProfile实体在尚未UserEntity实体的时,是休克独保存至数据库中之。】
  2. WithRequiredDependent():
    (from the MSDN) Configures the relationship to be required: required
    without a navigation property on the other side of the relationship.
    The entity type being configured will be the dependent and contain a
    foreign key to the principal. The entity type that the relationship
    targets will be the principal in the relationship.【WithRequiredDependent方法,从MSDN中所了然的音信是,配置关系是必须的,需要没有导航属性在其余一边。实体的系列将会面是独立的,并且包含一个着重的外键。】

Now define the connection string
in App.config file under EF.Dataproject so that we can
create database with the appropriate name.
The connectionstringis:

近日,在EF.Data类库中定义连接字符串配置文件音信,以便大家的次序可以创设数据库,连接字符串音讯是:

 

<connectionStrings>
    <add name="DbConnectionString" connectionString="Server=.;database=EFRelationshipStudyDB;uid=sa;pwd=Password_1" providerName="System.Data.SqlClient"/>
  </connectionStrings>

 

Now we
create a context class EFDbContext(EFDbContext.cs) that inherits
the DbContextclass. In this class, we override
the OnModelCreating()method. This method is called when the model for
a context class (EFDbContext) has been initialized, but before the
model has been locked down and used to initialize the context such that
the model can be further configured before it is locked down. The
following is the code snippet for the context class.

现行,我们成立一个数据库上下文类EFDbContext,这么些看似继承DbContext类,在那些数据库上下文类中,我们又写OnModelCreating方法,这一个OnModelCreating方法,在数据库上下文(EFDbContext)已经初始化的成功的早晚,被调用。可是在model被锁定在此以前,伊始化数据库上下文的时光,所以model可以以受锁定在此之前,进一步叫部署。下面是数据库上下文的代码:

using System;
using System.Collections.Generic;
using System.Data.Entity;
using System.Data.Entity.ModelConfiguration;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;

namespace EF.Data
{
    public class EFDbContext:DbContext
    {
        public EFDbContext()
            : base("name=DbConnectionString")
        { 
        }
        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            {
                var typesToRegister = Assembly.GetExecutingAssembly().GetTypes()
               .Where(type => !String.IsNullOrEmpty(type.Namespace))
               .Where(type => type.BaseType != null && type.BaseType.IsGenericType
                    && type.BaseType.GetGenericTypeDefinition() == typeof(EntityTypeConfiguration<>));
                foreach (var type in typesToRegister)
                {
                    dynamic configurationInstance = Activator.CreateInstance(type);
                    modelBuilder.Configurations.Add(configurationInstance);
                }
                base.OnModelCreating(modelBuilder);
            }  

        }
    }
}

As you
know, the EF Code First approach follows convention over configuration,
so in the constructor, we just pass the connection string name same as
an App.Config file and it connects to that server. In
theOnModelCreating()method, we used a reflection to map an entity to
its configuration class in this specific project.

总所周知,EF
Code
First方法,坚守约定大于配置标准,所以在构造函数中,大家就然则待传递连接字符串的讳,然后便可连续到数据库服务器了。在OnModelCreating方法吃,我们采纳了映,来为每个实体生成配置类。

We create
a Unit Test Project EF.UnitTestto test the code above. We create a
test class UserTestthat has a test method UserUserProfileTest().
This method creates a database and
populates UserandUserProfiletables as per their relationship. The
following is the code snippet for the UserTestclass.

本,我们接纳单元测试,来测试一下点写的代码。创立一个UserTest单元测试类,写一个UserUserProfileTest测试方法,那一个点子创制数据库,生成User和UserProfile数据库表,下边是代码:

 

using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.Data.Entity;
using EF.Data;
using EF.Core.Data;

namespace EF.UnitTest
{
    [TestClass]
    public class UserTest
    {
        [TestMethod]
        public void UserUserProfileTest()
        {
            //配置数据库初始化策略
            Database.SetInitializer<EFDbContext>(new CreateDatabaseIfNotExists<EFDbContext>());
            using(var db=new EFDbContext())
            {
                //创建数据库
                db.Database.Create();

                User userModel = new User()
                {
                    UserName = "Daniel",
                    Password = "123456",
                    AddedDate = DateTime.Now,
                    ModifiedDate = DateTime.Now,
                    IP = "1.1.1.1",
                    Email = "Daniel@163.com",
                    //一个用户,只有一个用户详情
                    UserProfile = new UserProfile() 
                    {
                    FirstName="曹",
                    LastName="操",
                    AddedDate=DateTime.Now,
                    ModifiedDate=DateTime.Now,
                    IP="1.2.3.45",
                    Address="宝安区 深圳 中国",
                    }

                };
                //设置用户示例状态为Added
                db.Entry(userModel).State = System.Data.Entity.EntityState.Added;
                //保存到数据库中
                db.SaveChanges();
            }
        }
    }
}

 

Now, run
the Testmethod and you get your table in the database with data. Run
selectquery in the database and get results like:

 

 

近期,运行测试方法,在数据库被即相会扭转这样的数据库,查询一下:

【不要遗忘了,在单元测试的类库项目中,也要写连接字符串的信息】

图片 6

图片 7

 

 

接下来看看数据库被之数码吧:

图片 8

 从扭转的数据库被,我们美观看,UserProfile表中之ID,即凡是主键也是外键,就是说,我们不克凭在UserProfile表中插入数据,也就是说,插入的数目,要当User表中存在记录。

还起个注意点:下面配置关系之时光,大家下的凡,

//配置关系[一个用户只能有一个用户详情!!!]
           this.HasRequired(s => s.User).WithRequiredDependent(s => s.UserProfile);

WithRequiredDependent现在,我们换成,WithRequiredPrincipal,结果生成的数据库是:

图片 9

 

可以看出来,这样就弄反了。。。。ID列应该是在UserProfile表中既是主键也是外键。

现在看看一对多的关系吧:

6.如果在一个B/S结构的系受待传递变量值,不过以不可知以Session、库克(Cook)ie、Application,您发出二种植形式开展拍卖?
答 : 
this.Server.Transfer

One-to-Many Relationship【一对几近干】

The
primary key table contains only one record that relates to none, one, or
many records in the related table. This is the most commonly used type
of relationship.

主键表的一个记录,关联到关联表中,存在,没有,或者有一个,或者多个记录。这是最重要的也是最常见的关系。

To
understand this relationship, consider an e-commerce system where a
single user can make many orders so we define two entities, one for
the customerand another for the order. Let’s take a look at the
following figure:

为更好之知一些多的干,可以联想到电子商务系统中,单个用户可生过多订单,所以我们定义了少单实体,一个凡客户实体,此外一个凡订单实体。大家看看下边的图样:

图片 10

 

下面是Custiomer实体代码:

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

namespace EF.Core.Data
{
  public  class Customer:BaseEntity
    {
      /// <summary>
      /// 客户名称
      /// </summary>
      public string Name { get; set; }

      /// <summary>
      /// 客户电子邮件
      /// </summary>
      public string Emial { get; set; }

      /// <summary>
      /// 导航属性--Order
      /// </summary>
      public virtual ICollection<Order> Orders { get; set; }
    }
}

Order实体:

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

namespace EF.Core.Data
{
   public class Order:BaseEntity
    {
       /// <summary>
       /// 数量
       /// </summary>
       public byte Quantity { get; set; }

       /// <summary>
       /// 价格
       /// </summary>
       public decimal Price { get; set; }

       /// <summary>
       /// 客户ID
       /// </summary>
       public int CustomerId { get; set; }

       /// <summary>
       /// 导航属性--Customer
       /// </summary>
       public virtual Customer Customer { get; set; }
    }
}

You have
noticed the navigation properties in the code above.
The Customerentity has a collection of Orderentity types and
the Orderentity has a Customerentity type property, that means
customercan make many orders.

公都于点的代码中注意到了领航属性,Customer实体有一个汇类型的Order属性,Order实体有一个Customer实体的领航属性,也就是说,一个客户可来为数不少订单。

Now
create a class, the CustomerMapclass in the EF.Dataproject to
implement the Fluent API configuration for the Customerclass.

兹以EF.Data项目遭到,定义一个CustomerMap类:

 

using EF.Core.Data;
using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations.Schema;
using System.Data.Entity.ModelConfiguration;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace EF.Data.Mapping
{
   public class CustomerMap:EntityTypeConfiguration<Customer>
    {
       public CustomerMap()
       {
           this.HasKey(s => s.ID);
           //properties  
           Property(t => t.ID).HasDatabaseGeneratedOption(DatabaseGeneratedOption.Identity);
           Property(t => t.Name);
           Property(t => t.Email).IsRequired();
           Property(t => t.AddedDate).IsRequired();
           Property(t => t.ModifiedDate).IsRequired();
           Property(t => t.IP);

           //table  
           ToTable("Customers");  
       }
    }
}

 

OrderMap类:

using EF.Core.Data;
using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations.Schema;
using System.Data.Entity.ModelConfiguration;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace EF.Data.Mapping
{
   public class OrderMap:EntityTypeConfiguration<Order>
    {
       public OrderMap()
       {
           this.HasKey(s=>s.ID);
           //fields  
           Property(t => t.ID).HasDatabaseGeneratedOption(DatabaseGeneratedOption.Identity);
           Property(t => t.Quanatity).IsRequired().HasColumnType("tinyint");
           Property(t => t.Price).IsRequired();
           Property(t => t.CustomerId).IsRequired();
           Property(t => t.AddedDate).IsRequired();
           Property(t => t.ModifiedDate).IsRequired();
           Property(t => t.IP);

           //配置关系【一个用户有多个订单,外键是CusyomerId】
           this.HasRequired(s => s.Customer).WithMany(s => s.Orders).HasForeignKey(s => s.CustomerId).WillCascadeOnDelete(true);

           //table  
           ToTable("Orders");  
       }
    }
}

The code
above shows that a Customeris required for each order and
the Customercan make multiple orders and relationships between both
made by foreign key CustomerId. Here, we use four methods to define
the relationship between both entities. The WithManymethod allows us
to indicate which property in Customercontains the Many relationship.
We add to that the HasForeignKeymethod to indicate which property
ofOrderis the foreign key pointing back to customer.
The WillCascadeOnDelete()method configures whether or not cascade
delete is on for the relationship.

下边的代码表示:用户在每个Order中是要的,并且用户可下多独订单,两独表明内通过外键CustomerId联系,我们运用了季单方法来定义实体之间的涉,Withmany方法允许多独。HasForeignKey方法表示哪个属性是Order表的外键,威尔(Will)CascadeOnDelete方法用来安排是否级联删除。

Now, we
create another unit test class in the EF.UnitTestProject to test the
code above. Let’s see the test method that inserts data for the customer
that has two orders.

现,我们当EF.UniTest类库项目蒙,成立另外的一个单元测试类。

 

using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using EF.Core.Data;
using System.Collections.Generic;
using EF.Data;
using System.Data.Entity;

namespace EF.UnitTest
{
    [TestClass]
    public class CustomerTest
    {
        [TestMethod]
        public void CustomerOrderTest()
        {
            Database.SetInitializer<EFDbContext>(new CreateDatabaseIfNotExists<EFDbContext>());
            using (var context = new EFDbContext())
            {
                context.Database.Create();
                Customer customer = new Customer
                {
                    Name = "Raviendra",
                    Email = "raviendra@test.com",
                    AddedDate = DateTime.Now,
                    ModifiedDate = DateTime.Now,
                    IP = "1.1.1.1",
                    Orders = new List<Order>{  
                                            new Order  
                                            {  
                                                Quanatity =12,  
                                                Price =15,  
                                                AddedDate = DateTime.Now,  
                                                ModifiedDate = DateTime.Now,  
                                                 IP = "1.1.1.1",  
                                            },  
                                            new Order  
                                            {  
                                                Quanatity =10,  
                                                Price =25,  
                                                AddedDate = DateTime.Now,  
                                                ModifiedDate = DateTime.Now,  
                                                 IP = "1.1.1.1",  
                                            }  
                                        }
                };
                context.Entry(customer).State = System.Data.Entity.EntityState.Added;
                context.SaveChanges();
            }  
        }
    }
}

 

运作测试。

图片 11

图片 12

 

 来探望数据库被的数码:

图片 13

 

最终看看,多对准大多之涉吧:

7.请编程遍历页面及享有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 ;
}
}

Many-to-Many Relationship【多对大多涉及】

Each
record in both tables can relate to any number of records (or no
records) in the other table. Many-to-many relationships require a third
table, known as an associate or linking table, because relational
systems can’t directly accommodate the relationship.

每条记下在有限个表中,都得以提到到其它一个表中的浩大记录【或者0条记录】。多对准多关系,需要第三着的阐发,也即使是关联表或者链接表,因为涉嫌项目数据库不能直接适应这种关系。

To
understand this relationship, consider an online course system where a
single studentcan join manycoursesand a coursecan have
many studentsso we define two entities, one for the studentand
another for the course. Let’s see the following figure for the
Many-to-Many relationship.

以重新好之明多对大多涉及,大家想到,有一个选课系统,一个学童好选秀很多学科,一个课可以为过多学员选修,所以我们定义六个实体,一个凡是Syudent实体,另外一个凡Course实体。大家来经图片看看,多针对多关系吧:

图片 14

 

 

 

Student实体:

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

namespace EF.Core.Data
{
   public class Student:BaseEntity
    {
        public string Name { get; set; }
        public byte Age { get; set; }
        public bool IsCurrent { get; set; }
        public virtual ICollection<Course> Courses { get; set; }  
    }
}

Course实体:

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

namespace EF.Core.Data
{
   public class Course:BaseEntity
    {
        public string Name { get; set; }
        public Int64 MaximumStrength { get; set; }
        public virtual ICollection<Student> Students { get; set; }  
    }
}

 

StudentMap类:

using EF.Core.Data;
using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations.Schema;
using System.Data.Entity.ModelConfiguration;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace EF.Data.Mapping
{
   public class StudentMap:EntityTypeConfiguration<Student>
    {
       public StudentMap()
       {
           //key  
           HasKey(t => t.ID);

           //property  
           Property(t => t.ID).HasDatabaseGeneratedOption(DatabaseGeneratedOption.Identity);
           Property(t => t.Name);
           Property(t => t.Age);
           Property(t => t.IsCurrent);
           Property(t => t.AddedDate).IsRequired();
           Property(t => t.ModifiedDate).IsRequired();
           Property(t => t.IP);

           //table  
           ToTable("Students");  

           //配置关系[多个课程,可以被多个学生选修]
           //多对多关系实现要领:hasmany,hasmany,然后映射生成第三个表,最后映射leftkey,rightkey
           this.HasMany(s => s.Courses).
               WithMany(s => s.Students)
               .Map(s => s.ToTable("StudentCourse").
                   MapLeftKey("StudentId").
                   MapRightKey("CourseId"));
       }
    }
}

The code
snippet above shows that one studentcan join many coursesand
each coursecan have manystudents. As you know, to implement
Many-to-Many relationships, we need a third table namedStudentCourse.
The MapLeftKey()and MapRightKey()methods define the key’s name in
the third table otherwise the key name is automatically created
with classname_Id. The Left key or first key will be that in which we
are defining the relationship.

地方的代码中,表示,一个生好选修多独学科,并且每个课程可以暴发过多学生,你懂,实现多对大多的涉及,大家得第三单表达,所以我们映射了第四只表达,mapLeftkey与maprightkey定义了第两个表中的键,如若大家无指定的话,就汇合按部就班预约生成类名_Id的键。

Now
create a class, the CourseMapclass, in the EF.Dataproject to
implement the Fluent API configuration for the Courseclass.

兹探访CourseMap类:

 

using EF.Core.Data;
using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations.Schema;
using System.Data.Entity.ModelConfiguration;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace EF.Data.Mapping
{
   public class CourseMap:EntityTypeConfiguration<Course>
    {
       public CourseMap()
       {
           this.HasKey(t => t.ID);//少了一行代码
           //property  
           Property(t => t.ID).HasDatabaseGeneratedOption(DatabaseGeneratedOption.Identity);
           Property(t => t.Name);
           Property(t => t.MaximumStrength);
           Property(t => t.AddedDate).IsRequired();
           Property(t => t.ModifiedDate).IsRequired();
           Property(t => t.IP);

           //table  
           ToTable("Courses");           
       }
    }
}

 

于来创设一个单元测试类:

using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using EF.Core.Data;
using System.Collections.Generic;
using EF.Data;
using System.Data.Entity;

namespace EF.UnitTest
{
    [TestClass]
    public class StudentTest
    {
        [TestMethod]
        public void StudentCourseTest()
        {
            Database.SetInitializer<EFDbContext>(new CreateDatabaseIfNotExists<EFDbContext>());
            using (var context = new EFDbContext())
            {
                context.Database.Create();
                Student student = new Student
                {
                    Name = "Sandeep",
                    Age = 25,
                    IsCurrent = true,
                    AddedDate = DateTime.Now,
                    ModifiedDate = DateTime.Now,
                    IP = "1.1.1.1",
                    Courses = new List<Course>{  
                        new Course  
                        {  
                            Name = "Asp.Net",  
                            MaximumStrength = 12,  
                            AddedDate = DateTime.Now,  
                            ModifiedDate = DateTime.Now,  
                            IP = "1.1.1.1"  
                        },  
                         new Course  
                        {  
                            Name = "SignalR",  
                            MaximumStrength = 12,  
                            AddedDate = DateTime.Now,  
                            ModifiedDate = DateTime.Now,  
                            IP = "1.1.1.1"  
                        }  
                    }
                };
                Course course = new Course
                {
                    Name = "Web API",
                    MaximumStrength = 12,
                    AddedDate = DateTime.Now,
                    ModifiedDate = DateTime.Now,
                    IP = "1.1.1.1",
                    Students = new List<Student>{  
                        new Student  
                        {  
                            Name = "Raviendra",  
                            Age = 25,  
                            IsCurrent = true,  
                            AddedDate = DateTime.Now,  
                            ModifiedDate = DateTime.Now,  
                            IP = "1.1.1.1",  
                        },  
                         new Student  
                        {  
                          Name = "Pradeep",  
                        Age = 25,  
                        IsCurrent = true,  
                        AddedDate = DateTime.Now,  
                        ModifiedDate = DateTime.Now,  
                        IP = "1.1.1.1",  
                        }  
                    }
                };
                context.Entry(student).State = System.Data.Entity.EntityState.Added;
                context.Entry(course).State = System.Data.Entity.EntityState.Added;
                context.SaveChanges();
            }  
        }
    }
}

 

 

 运行测试:

图片 15

探望数据库被之多少吧:

图片 16

 

图片 17

 

图片 18

8.请编程实现一个冒泡排序算法?
答:
int [] array = new int 
;
int temp = 0 ;
for (int i = 0 ; i < array.Length – 1 ; i++)
{
for (int j = i + 1 ; j < array.Length ; j++)
{
if (array[j] < array[i])
{
temp = array[i] ;
array[i] = array[j] ;
array[j] = temp ;
}
}
}

Conclusion【总结】

This
article introduced relationships in the Entity Framework Code First
approach using the Fluent API. I didn’t use database migration here;
that is why you need to delete your database before running any test
method of the unit.

眼看首作品,介绍了EF
CodeFirst
格局,这里自辛未曾动数据库迁移技术,这虽然不怕是为何你每回运行单元测试以前,都设先删掉数据库的缘故。

 

小结:翻译真是一桩苦差事,前边的稿子,我打算采用好的语言来社团,写出来。一字一句的翻,真的蛮浪费时间,就算我眷恋愈提升捷克语能力,但,确实翻译耗费时间啊。但为分享文化,我要翻译出了。希望大家爱不释手。~~~

 

 

 

 

9.描述一下C#中索引器的实现过程,是否只好依照数字举办索引?
报经:不是。可以就此随机档次。

10.求以下表明式的值,写来而想到的均等种植要二种植实现模式: 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());
System.Console.ReadLine() ;

11.为此.net做B/S结构的网,您是为此几重叠协会来支付,每一样叠内的涉与为什么而这么分层?
答:一般为3层
多少访问层,业务层,表示层。
数量访问层对数据库举办增删查改。
业务层一般分为二层,业务表观层实现同代表层的互换,业务规则层实现用户密码的安等。
代表层为与用户交互例如用户增长表单。
亮点: 分工明确,条理清晰,易于调试,而且具备可扩张性。
缺点: 扩充资金。

12.以脚的例证里
using System;
class A
{
public A()
{
PrintFields();
}
public virtual void PrintFields(){}
}
class B:A
{
int x=1;
int y;
public B()
{
y=-1;
}
public override void PrintFields()
{
Console.WriteLine(“x={0},y={1}”,x,y);
}
当用new B()创制B的实例时,发生什么输出?
答:X=1,Y=0;x= 1 y = -1

13.呀吃应用程序域?
报:应用程序域可以领悟呢同一种轻量级进程。起至平安之来意。占用资源小。

14.CTS、CLS、CLR分别作何解释?
报:CTS:通用语言体系。CLS:通用语言专业。CLR:公共语言运行库。

15.哟是装箱和拆箱?
答:从值类型接口转换来引用类型装箱。从引用类型转换来值类型拆箱。

16.哟是叫管制之代码?
报:unsafe:非托管代码。不经过CLR运行。

17.哟是强类型系统?
答:RTTI:类型识别系统。

18.net曰镪读写数据库需要以这么些看似?他们之图?
报经:DataSet:数据存储器。
DataCommand:执行报告句发号施令。
DataAdapter:数据的聚集,用语填充。

19.ASP.net的身份验证模式来什么?分别是呀规律?
答:10。Windwos(默认)用IIS…From(窗体)用帐户….Passport(密钥)

20.什么是Code-Behind技术?
报:代码后植。

21.当.net中,配件的意思是?
答:程序集。(中间语言,源数据,资源,装配清单)

22.常用的调用WebService(Service)的法来安?
报:1.以WSDL.exe命令行工具。
2.动VS.NET中的Add
Web Reference菜单选项

23..net Remoting 的劳作规律是啊?
报:服务器端向客户端发送一个历程编号,一个程序域编号,以确定目的的职。

24.每当C#中,string str = null
与 string str = “”
请尽量采取文字或图象表明里的区分。 
报经:string str = null
是休深受他分配内存空间,而string str = “”
给它分配长度为空字符串的内存空间。

25.伸手详述在dotnet中类(class)与布局(struct)的异同?
报:Class可以于实例化,属于引用类型,是分配在内存的积聚上之,Struct属于值类型,是分配在内存的栈上的.

26.冲委托(delegate)的知,请完以下用户控件被代码有的填充: 
namespace test 

public delegate void OnDBOperate(); 
public class UserControlBase : System.Windows.Forms.UserControl 

public event OnDBOperate OnNew; 
privatevoidtoolBar_ButtonClick(objectsender,System.Windows.Forms.ToolBarButtonClickEventArgs
e)

if(e.Button.Equals(BtnNew)) 

//请在偏下补齐代码用来调用OnDBOperate委托签名的OnNew事件。


}
答:if( OnNew != null ) 
OnNew( this, e ); 

27.分析以下代码,完成填空 
string strTmp = “abcdefg某某某”; 
int i= System.Text.Encoding.Default.GetBytes(strTmp).Length; 
int j= strTmp.Length; 
如上代码执行完后,i= j= 
答:i=13,j=10 

28.SQLSERVER服务器受到,给定表 table1 中发出些许独字段
ID、LastUpdateDate,ID表示更新的事务号,
LastUpdateDate表示更新时之服务器时间,请以同样句SQL语句得到最后更新的事务号
答:Select ID FROM table1 Where LastUpdateDate
= (Select MAX(LastUpdateDate) FROM table1) 

29.冲线程安全的有关知识,分析以下代码,当调用test方法时i>10时是否相会挑起死锁?并简要表明理由。
public void test(int i) 

lock(this) 

if (i>10) 

i–; 
test(i); 


}
答:不碰面来死锁,(但生几许int是本值传递的,所以每一回转之都单是一个副本,因而无会合产出死锁。但尽管将int换做一个object,那么死锁会暴发)

30.简一旦提一下若对微软.NET 构架下remoting和webservice两项技术之了然与实际被的使用。
报:WS重假设不过使HTTP,穿透防火墙。而Remoting可以利用TCP/IP,二进制传送提高效能。

31.供销社求支付一个继续System.Windows.Forms.ListView类的组件,要求上以下的出格效用:点击ListView各列列头时,能按照点击列的诸行值举行重排视图中之有着行 (排序的主意使DataGrid相似)。按照你的知识,请简要谈一下公的思路
报经:按照点击的列头,包该列的ID取出,遵照该ID排序后,在吃绑定到ListView中。

32.给一定以下XML文件,完成算法流程图。
 
< DriverC > 

 

 
 
 
 

求画出遍历所有文件称(FileName)的流程图(请用递归算法)。
答:
void FindFile( Directory d ) 

FileOrFolders = d.GetFileOrFolders(); 
foreach( FileOrFolder fof in FileOrFolders ) 

if( fof is File ) 
You Found a file; 
else if ( fof is Directory ) 
FindFile( fof ); 

}

33.描写起同修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) 

34.面向对象的言语有________性、_________性、________性
答:封装、继承、多态。

35.可以为此foreach遍历访问的目的要贯彻
________________接口或阐明________________道的花色。
答:IEnumerable 、
GetEnumerator。

36.GC是呀? 为啥要有GC?
答:GC是污染源收集器。程序员不用顾虑内存管理,因为废品收集器会自动举行田间管理。要告垃圾收集,可以调用下边的法门之一: 
System.gc()
Runtime.getRuntime().gc()

37.String s = new String(“xyz”);创造了几单String Object?
答:两独对象,一个是“xyx”,一个是负为“xyx”的援对象s。

38.abstract class与interface有什么界别?
报经:注解方法的有如非失实现其的类似让誉为抽象类(abstract
class),它用来要创一个反映某些基本表现的切近,并为此类表明方法,但不克于此类中落实该类的情况。不可能创abstract
类的实例。可是可以创造一个变量,其色是一个抽象类,并于她对具体子类的一个实例。无法闹抽象构造函数或抽象静态方法。Abstract
类的子类为它父类中的有抽象方法供实现,否则她啊是架空类为。取而代之,在子类中贯彻该方法。知道该一言一行之此外类可以在相近吃实现这个艺术。
接口(interface)是抽象类的变体。在接口中,所有方仍旧纸上谈兵的。多继承性可经实现这样的接口而取得。接口中之所有方都是架空的,没有一个生程序体。接口就可以定义static
final成员变量。接口的实现同子类相似,除了该实现类不克于接口定义中继承行为。当类实现特殊接口时,它定义(即将程序体给予)所有这种接口的计。然后,它好在实现了该接口的类似的另对象及调用接口的不二法门。由于有抽象类,它同意下接口名作为援变量的档次。经常的动态联编将生效。引用得变换到接口类型或由接口类型转换,instanceof
运算符可以为此来控制有目的的接近是否实现了接口。

39.起步一个线程是用run()如故start()?
答:启动一个线程是调用start()方法,使线程所代表的杜撰处理机处于可运行状态,这代表她好由JVM调度并尽。这并无代表线程就会师及时运行。run()方法可以有必须退出的标志来住一个线程。

40.接口是否可继续接口? 抽象类是否只是实现(implements)接口?
抽象类是否可连续实体类(concrete class)?
报:接口能够持续接口。抽象类可兑现(implements)接口,抽象类是否可继承实体类,但前提是实体类必须来显然的构造函数。

41.构造器Constructor是否可叫override?
答:构造器Constructor不克为连续,由此不可知再次写Overriding,但好于重载Overloading。

42.是不是好持续String类?
报:String类是final类故不可以连续。

43.try {}里生一个return语句,那么紧跟在这么些try后的finally {}里之code会不会师于实践,何时吃执行,在return前仍旧后?
答:会执行,在return前执行。

44.星星独对象值相同(x.equals(y) == true),但也唯独有异的hash code,这句话对怪?
报经:不对,有平等之hash code。

45.swtich是否会图在byte上,是否会图在long上,是否可以图在String上?
报:switch(expr1)中,expr1凡一个整数表明式。因而传递给
switch 和 case 语句之参数应该是 int、 short、 char 或者 byte。long,string 都非克图为swtich。

47.当一个线程进入一个目的的一个synchronized方法后,此外线程是否只是上者目的的旁形式?
匪可知,一个对象的一个synchronized方法才会由一个线程访问。

48.abstract底method是否只是同时是static,是否可又是native,是否只是又是synchronized?
答:都不能。

49.List, Set, Map是否持续自Collection接口?
答:List,Set是Map不是

50.Set里的元素是未可以还的,那么用什么措施来区分重复与否呢? 是故==如故equals()? 它们发出什么地方区别?
报:Set里之要素是未克还的,那么因此iterator()方法来分重复与否。equals()是判读两单Set是否等于。
equals()和==方法决定引用值是否对准同一对象equals()在相近中让埋,为的是当半单分其余靶子的情节和花色相配的话语,重返真值。

 

51.数组发生没来length()这一个主意?
String有没有出length()那么些法?
答:数组没有length()那么些形式,有length的性质。String有出length()那个法子。

52.sleep() 和 wait() 有什么分别?
报经:sleep()方法是要是线程截止一段时间的主意。在sleep
时间距离期满后,线程不肯定就过来执行。这是为当非凡时刻,其余线程可能正周转而没有吃调度为吐弃举办,除非(a)“醒来”的线程具有双重胜似的先行级
(b)正于运转的线程因为另外由一旦死。
wait()是线程交互时,要是线程对一个齐对象x
发出一个wait()调用,该线程会暂停实施,被调对象上待状态,直到被唤醒或等候时到。

53.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正确。

54.谈谈final, finally, finalize的区别。
答:
final—修饰符(关键字)如若一个好像吃声称也final,意味着其不可能重派生出新的子类,不克作为父类被连续。由此一个近似无法既让声称也 abstract的,又给声称也final的。将变量或形式表明也final,可以保它在采纳受到 不吃改动。被声称也final的变量必须以宣称时给一定新值,而以之后的援中只可以读取,不可修改。被声称也 final的法为同样只可以选择,不可能重载
finally—再大处理时提供 finally
块来实施外清除操作。虽然丢弃来一个那一个,那么相匹配的 catch 子句就会合 执行,然后决定就会进来 finally 块(假设有的言语)。
finalize—方法名。Java 技术允许使用 finalize()方法以垃圾收集器将对象从内存中消除出在此之前做必要之清理
工作。这多少个措施是由于垃圾收集器在规定这些目的没于引述时对是目的调用的。它是当 Object 类中定义之
,由此有的类都继承了它。子类覆盖 finalize()方法以盘整系统资源或者实施外清理工作。finalize()方法是当渣收集器删除对象以前对之目的调用的。

55.怎么着处理几十万长长的现身数据?
答:用存储过程要业务。取得最老标识的上又更新..注意主键不是于增量形式这种艺术并发的下是免会晤生出再次主键的..取得最特别标识要来一个储存过程来得到取.

56.Session有啊重要BUG,微软提出了哟措施加以解决?
答:是iis中由起经过回收机制,系统繁忙的话Session会少,可以就此Sate
server或SQL Server数据库的道囤Session不过这种方法比慢,而且不可能捕获Session的END事件。

57.历程以及线程的区别?
报:进程是系举办资源分配和调度的单位;线程是CPU调度以及分担的单位,一个过程可以发生两只线程,这么些线程共享斯进程的资源。

58.堆和货栈的分?
答:
库房:由编译器自动分配、释放。在部数体中定义之变量平时以栈上。
堆:一般由程序员分配释放。用new、malloc等分配内存函数分配拿到的便是以堆上。

59.成员变量和分子函数前加static的图?
答:它们于号称常成员变量和时成员函数,又曰类成员变量和接近成员函数。分别就此来反映类似的状态。比如类似成员变量可以据此来总结类实例的多少,类成员函数负责这种统计的动作。

60.ASP。NET与ASP相相比较,重要有咋样发展?
报:asp解释形,aspx编译型,性能进步,有利于保障源码。

61.来一个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];

62.请表明当.net中常用之几栽页面中传递参数的道,并说发她们之利害。
报经:session(viewstate)
简单,但爱丢
application 全局
cookie 简单,但或许未帮忙,可能吃冒用
input ttype=”hidden” 简单,可能受仿冒
url参数 简单,展现为地址栏,长度有限
数据库 稳定,安全,但性能相对弱

63.请指出GAC的含义?
报经:全局程序集缓存。

64.朝着服务器发送请求有几乎种办法?
报:get,post。get一般也链接形式,post一般也按钮格局。

65.Data里德r与Dataset有啊区别?
报经:一个是不得不上的仅仅读游标,一个凡是外存中的发明。

66.软件开发过程相似发生多少个阶段?每个阶段的意?
报经:需求分析,架构设计,代码编写,QA,部署

67.在c#中using和new这有限只举足轻重字来什么意思,请写有而所知晓之含义?using 指令 和言语 new
创立实例 new 隐藏基类中法。
报经:using
引入名称空间或使用非托管资源
new 新建实例或者藏父类方法

68.需要实现对一个字符串的处理,首先以该字符串首尾的空格去丢,倘若字符串中间还有连续空格的话,仅保留一个空格,即允许字符串中间闹差不三只空格,但连接的空格数不可过一个.
答:string inputStr=” xx xx “;
inputStr=Regex.Replace(inputStr.Trim(),” *”,” “);

69.下边就段代码输出什么?为啥?
int i=5;
int j=5;
if (Object.ReferenceEquals(i,j))
Console.WriteLine(“Equal”);
else
Console.WriteLine(“Not Equal”);
报:不抵,因为相比的是目标

70.啊叫SQL注入,如何防范?请举例表达。
报经:利用sql关键字对网站举办攻击。过滤关键字’等

71.哟是反射?
答:动态获取程序集消息

72.为此Singleton咋样勾勒设计情势
答:static属性里面new ,构造函数private

73.什么是Application Pool?
报:Web应用,类似Thread Pool,提升并发性能。

74.呀是虚函数?什么是空泛函数?
报经:虚函数:没有实现之,可由子类继承并重写的函数。抽象函数:规定其非虚子类必须贯彻之函数,必须给重写。

75.什么是XML?
报经:XML即可扩张标记语言。eXtensible 马克(Mark)up
Language.标记是借助统计机所可以明白的消息记,通过这种标志,总结机中可以拍卖包含各个音信之稿子等。如何定义这么些标记,即可以选择国际通用的符语言,比如HTML,也可以动用象XML这样由相关人员任意支配的号语言,这即是语言的不过扩大性。XML是从SGML中简化修改出来的。它最紧要拔取的产生XML、XSL和XPath等。

 

76.什么是Web Service?UDDI?
报经:Web
Service(Service)便是因网络的、分布式的模块化组件,它执行一定的天职,坚守具体的技术专业,那一个专业使得Web Service(Service)能与此外兼容的组件举行互操作。
  UDDI
的目的是吧电子商务建立正式;UDDI是平等模拟基于Web的、分布式的、为Web
瑟维斯(Service)提供的、信息报中央的贯彻标准规范,同时也包含一组要公司能以自我提供的Web
瑟维斯(Service)注册,以使其它集团可以察觉的看协议的落实规范。
77.啊是ASP.net中的用户控件?
报:用户控件一般用当情节多呢静态,或者简单会变动的情下..用的较大..类似ASP中之include..但是意义而强硬的大都。

78.列举一下你所了解之XML技术及其应用
报:xml用于配置,用于保存静态数据类型.接触XML最多的凡web Services..和config

79.ADO.net中常用的目的来哪些?分别讲述一下。
报:Connection 数据库连接对象
Command 数据库命令
Data里德r 数据读取器
DataSet 数据集

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

81.什么是SOAP,有哪应用。
答:simple object access
protocal,简单对象接受协议.以xml为中央编码结构,建立以曾经暴发通信协议上(如http,然而据说ms在抓最底部的架构在tcp/ip上的soap)的平栽标准Web
瑟维斯(Service)使用的协议..

82.C#中 property 与
attribute的界别,他们各暴发什么用处,这种机制的好处在何?
答:一个凡性质,用于存取类的字段,一个是特色,用来标识类,方法等的附加性质

83.XML 与 HTML 的严重性区别
答:1. XML凡分好小写字母的,HTML不分。 

  1. 以HTML中,倘使达下文清楚地亮有段落或者列表键在何方结尾,那么您得略

或者等等的收尾
标记。在XML中,相对免克省略掉了标记。 

  1. 以XML中,拥有单个标记而无匹配的结标记的因素必须用一个 / 字符作为最后。这样分析器就知毫无
    查找了标记了。 
  2. 每当XML中,属性值必须分开作在引号中。在HTML中,引号是可用可不要的。 
  3. 每当HTML中,能够有所不带值的属性名。在XML中,所有的性质都必须包含相应的价。

84.c#屡遭之老三首先运算符是?
答:?:。

85.当平头a赋值给一个object对象时,整数a将会让?
答:装箱。

86.类成员暴发_____种植而看形式?
答:this.;new Class().Method;

87.public static const int A=1;这段代码来错误么?是什么?
答:const不能用static修饰。

88.float f=-123.567F; int i=(int)f;i的值现在是_____? 
答:-123。

89.委托讲明的显要字是______?
答:delegate.

90.用sealed修饰的切近爆发什么特色?
报经:密封,不能延续。

91.以Asp.net中兼有的自定义用户控件都必须继续自________?
答:Control。

92.于.Net中保有可连串化的接近都深受记为_____? 
答:[serializable]

93.每当.Net托管代码中大家不用担心内存漏洞,这是为有矣______?
答:GC。

94.底的代码中有啊错啊?_______
using System;
class A
{
public virtual void F(){
Console.WriteLine(“A.F”);
}
}
abstract class B:A
{
public abstract override void F(); 答:abstract override 是匪能够一起修饰. 
} // new public abstract void F();

95.当类T只表明了私家实例构造函数时,则在T的先后文件外部,___可以___(可以 or
不得以)从T派生出新的切近,不可以____(可以 or
不可以)间接创建T的此外实例。
答:不可以,不可以。

96.底下就段代码来错误么?
switch (i){
case(): 答://case()条件不可知为空
CaseZero();
break;
case 1:
CaseOne();
break;
case 2:
dufault; 答://wrong,格式不得法
CaseTwo();
break;
}

97.每当.Net中,类System.Web.UI.Page
可以给随即承么?
答:可以。

98..net之错误处理机制是呀?
答:.net错误处理机制使try->catch->finally结构,暴发误时,层层上扔,直到找到匹配的Catch结束。

99.用operator阐明且只宣称了==,有啊错误么?
报经:要又修改Equale和GetHash() ? 重载了”==”
就不可能不重载 “!=”

100.在.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; 

}

 

101.在.net(C# or
vb.net)中如何废除一个窗体的关闭。
答:private void Form1_Closing(object sender,
System.ComponentModel.CancelEventArgs e)
{
e.Cancel=true;

102.在.net(C# or
vb.net)中,Appplication.Exit 仍旧 Form.Close有啊不同?
报经:一个凡是脱整个应用程序,一个凡关内部一个form。

103.在C#遭起一个double型的变量,比如10321.5,比如122235401.21644,作为货币的价值什么以梯次不同国度之习惯来输出。比如U.S.A.用$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);

104.有平密码唯有使用K、L、M、N、O共5单字母,密码被之单词从左为右边排列,密码单词必须比照如下规则:
(1)
密码单词的太小尺寸是有限独字母,可以同,也得以不同
(2)
K不能够是就词的率先独字母
(3) 假诺L现身,则出现次数不止一回
(4)
M不可知而末段一个为未能够是最后多少个第二单字母
(5)
K出现,则N就自然出现
(6)
O如果是终极一个假名,则L一定出现
问题一样:下列哪一个字母可以在LO中之O前面,形成一个3只假名的密码单词?
A) K B)L C) M D) N
答案:B

题目二:假如会得到的假名是K、L、M,那么能形成的少数个字母长的密码单词的总和是微?
A)1个 B)3个
C)6个 D)9个
答案:A

题目三:下列哪一个是单词密码?
A) KLLN B) LOML C) MLLO D)NMKO
答案:C

  1. 62-63=1 等式不树立,请动一个数字(不可以走减号和等于号),使得等式创制,咋样运动?
    答案:62移动成2的6次方

105.对如此的一个枚举类型:
enum Color:byte
{
Red,
Green,
Blue,
orange
}
答:string[]
ss=Enum.GetNames(typeof(Color));
byte[] bb=Enum.GetValues(typeof(Color));

  1. C#中 property 与
    attribute的分别,他们每发啊用处,这种体制的好处在何?
    报:attribute:自定义属性之基类;property :类中之特性

107.C#能否对内存举行直接的操作?
报:在.net下,.net引用了垃圾堆回收(GC)功效,它代表了程序员 不了在C#饱受,不可知从来促成Finalize方法,而是以析构函数吃调用基类的Finalize()方法

108.ADO。NET相对于ADO等首要发生啊革新?
报:1:ado.net不指于ole db提供次,而是使用.net托管提供的程序,2:不拔取com3:不以支撑动态游标和服务器端游
4:,能够断开connection而保留当前数据集可用
5:强类型转换 6:xml匡助

109.状一个HTML页面,实现以下功效,左键点击页面时显得“您好”,右键点击时显示“禁止右键”。并当2分钟后自动关闭页面。
答:

110.大概讲述一下ASP。NET服务器控件的生命周期
报经:最先化 加载视图状态 处理回发数据 加载 发送回发更改通告处理回发事件 预展现 保存状态 显示 处置 卸载

111.Anonymous Inner Class (匿名内部类) 是否足以extends(继承)另外类,是否好implements(实现)interface(接口)?
报经:不可知,能够实现接口

112.Static Nested Class 和 Inner Class的不同,说得越多越好
答:Static Nested
Class是受声称也静态(static)的里类,它能够不指让表面类实例被实例化。而平凡的其中类需要以外表类实例化后才可以实例化。

113.,&和&&的区别。
&是各类运算符,表示按位与运算,&&是逻辑运算符,表示逻辑和(and).

114.HashMap和Hashtable的区别。
报:HashMap是Hashtable的轻量级实现(非线程安全的贯彻),他们还好了Map接口,重要分在HashMap允许空(null)键值(key),由于非线程安全,效能及恐怕高于Hashtable.

115.short s1 = 1; s1 = s1 + 1;有啊错? short s1 = 1; s1 += 1;有什么错?
报:short s1 = 1; s1 = s1 + 1; (s1+1运算结果是int型,需要强制转换类型)
short s1 = 1; s1 += 1;(可以是编译)

116.Overloaded之法子是否可转再次来到值的品种?
报:Overloaded的主意是可变更重临值的色。

117.error跟exception有什么区别?
报:error
代表復苏不是不容许可是万分艰苦的气象下之同种植严重问题。比如说内存溢出。不能要程序会处理这样的情形。
exception
代表无异栽设计要促成问题。也就是说,它表示假设程序运行正常,从不会出的情。


  1. 有啊区别?
    报经:表示绑定的数据源
    举凡劳动器端代码块

119.君看ASP.NET 2.0(VS2005)和公先下的开发工具(.Net
1.0或者其他)有啊最特别之区别?你当往日的阳台及采取的焉开发合计(pattern / architecture)可以移植到ASP.NET 2.0上
(或者都内嵌在ASP.NET 2.0遭)
报经:1 ASP.NET 2.0
把一些代码举办了包打包,所以对待1.0平效用裁减了累累替码.
2 同时协理代码分离及页面嵌入服务器端代码三种植情势,从前1.0版本,.NET指示救助唯有以分别之代码文件,无 法 在页面嵌入服务器端代码得到救助指示,
3 代码和统筹界面切换的时刻,2.0扶助光标定位.这一个我于好
4 在绑定数据,做表的分页.Update,Delete,等操作都足以可视化操作,方便了初学者
5 在ASP.NET中扩充了40几近独新的控件,裁减了工作量

120.重载跟覆盖的分别?
报经:1、方法的幂是子类和父类之间的涉及,是直关系;方法的重载是与一个接近吃智中的关系,是程度关系
2、覆盖只可以出于一个术,或只好由片智暴发关系;方法的重载是基本上单主意中的关系。
3、覆盖要求参数列表相同;重载要求参数列表不跟。
4、覆盖关系面临,调用这一个方法体,是基于目的的品类(对象对承诺存储空间类型)来支配;重载关系,是冲调
用时之实参表与显参表来挑选方法体的。

121.讲述一下C#中索引器的落实过程,是否只好按照数字举办索引? 
报经:不是。可以为此随意档次。

122.在C#中,string str = null
与 string str = ” ”
请尽量选择文字或图象表明里的区别。
报经:null是绝非空间引用的;
” ” 是空间为0的字符串;

123.分析以下代码,完成补给
string strTmp = “abcdefg某某某”; 
int i= System.Text.Encoding.Default.GetBytes(strTmp).Length; 
int j= strTmp.Length;
上述代码执行完后,i= j= 
答:i=13.j=10

124.SQLSERVER服务器被,给定表 table1 中暴发一定量独字段
ID、LastUpdateDate,ID表示更新的事务号,
LastUpdateDate表示更新时的服务器时间,请动相同句子SQL语句拿到最终更新的事务号
答:Select ID FROM table1 Where LastUpdateDate
= (Select MAX(LastUpdateDate) FROM table1) 

125.解析以下代码。
public static void test(string ConnectString) 

System.Data.OleDb.OleDbConnection conn = new
System.Data.OleDb.OleDbConnection(); 
conn.ConnectionString = ConnectString; 
try 


conn.Open(); 
……. 
}
catch(Exception Ex) 

MessageBox.Show(Ex.ToString()); 
}
finally 

if (!conn.State.Equals(ConnectionState.Closed)) 
conn.Close(); 

}
请问 

1)以上代码可以是运用连接池吗? 

报经:回答:就算传入的connectionString是如出一辙模一样的话,能够对利用连接池。可是同样型一样的意思是,连字符的空格数,顺序完全一致。 

2)以上代码所使用的要命处理方法,是否拥有以test方法外之可怜都足以给捕捉并显示出来? 

报:只好捕捉数据库连接着之老吧. (finally中,catch中,假设有此外可能引发那些的操作,也当据此try,catch。所以理论及无须所有大且会合受捕捉。) 

126.合作社要求开发一个延续System.Windows.Forms.ListView类的零件,要求及以下的异意义:点击ListView各列列头时,能按点击列的各行值举行重排视图中之有所行 (排序的措施如DataGrid相似)。依照你的学问,请简要谈一下君的思绪:
答:按照点击的列头,包该列的ID取出,依照该ID排序后,在为绑定到ListView中

127.啊是WSE?近日风行的本是小?
报:WSE (Web 瑟维斯(Service)(Service) Extension)
包来供新型的WEB服务安全确保,近日最新版本2.0。

128.当底下的例子里
using System;
class A
{
public A(){
PrintFields();
}
public virtual void PrintFields(){}
}
class B:A
{
int x=1;
int y;
public B(){
y=-1;
}
public override void PrintFields(){
Console.WriteLine(“x={0},y={1}”,x,y);
}
当使用new B()创立B的实例时,爆发什么输出?
答:X=1,Y=0

129.底下的事例中
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

130.abstract class和interface有啊分别?
答:表明方法的留存而休失实现它的切近让称为抽像类(abstract
class),它用来要创一个显示某些基本行为的接近,并也此类注解方法,但切莫克当此类中贯彻该类的情形。不可知创abstract
类的实例。可是能够创制一个变量,其连串是一个抽像类,并叫其对具体子类的一个实例。不可能发出抽像构造函数或抽像静态方法。Abstract
类的子类为它父类中的装有抽像方法供实现,否则它们也是抽像类为。取而代之,在子类中贯彻该措施。知道该作为的别样类可以在看似中实现这一个主意。
接口(interface)是抽像类的变体。在接口中,所有方都是抽像的。多继承性可经过落实这样的接口而获。接口中之拥有方仍然抽像的,没有一个暴发程序体。接口就可定义static
final成员变量。接口的实现和子类相似,除了该实现类不克自接口定义中延续行为。当类实现特殊接口时,它定义(即将程序体给予)所有这种接口的主意。然后,它好在贯彻了拖欠接口的好像的外针对诸如上调用接口的方。由于起抽像类,它同意下接口名作为援变量的型。日常的动态联编将生效。引用得变换来接口类型或打接口类型转换,instanceof
运算符能够就此来控制之一目的的切近是否实现了接口。

 

Leave a Comment.