精华内容
下载资源
问答
  • C#为我们提供了一个Guid,可以轻松的获取到规则的唯一值(标识),具体的方法如下:using System;...private static void CreatGuid(){Response.Write("GUID:" + Guid.NewGuid().ToString())...

    在实际的设计当中,我们往往在许多地方需要用到不规则的唯一值(标识),比如在购物车ID、数据标识、消息队列的标识等等。C#为我们提供了一个Guid,可以轻松的获取到不规则的唯一值(标识),具体的方法如下:

    using System;

    ...

    private static void CreatGuid()

    {

    Response.Write("GUID:" + Guid.NewGuid().ToString());

    }

    ...

    下面来写一个生成GUID的函数:

    private string getGUID()

    {

    System.Guid guid = new Guid();

    guid = Guid.NewGuid();

    string str = guid.ToString();

    return str;

    }

    随机生成如下字符串:e92b8e30-a6e5-41f6-a6b9-188230a23dd2

    格式说明:

    System.Guid.NewGuid().ToString(format)

    格式说明符

    返回值的格式

    N 32位:

    xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

    如:e92b8e30a6e541f6a6b9188230a23dd2

    D 由连字符分隔的32位数字:

    xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx

    如:e92b8e30-a6e5-41f6-a6b9-188230a23dd2

    B 括在大括号中、由连字符分隔的32位数字:

    {xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx}

    如:{e92b8e30-a6e5-41f6-a6b9-188230a23dd2}

    P 括在圆括号中、由连字符分隔的32位数字:

    (xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx)

    如:(e92b8e30-a6e5-41f6-a6b9-188230a23dd2)

    声明:转载本文请注明来源于西部e网(weste.net)。

    展开全文
  • LINQ之对象标识

    2010-07-02 15:29:00
    关系数据库表中的行具有唯一标识。由于每一行都具有唯一的主键,因此任何两行都不会共用同一键值。 实际上,通常我们是将数据从数据库中提取出来放入另一层中,应用程序在该层对数据进行处理。这就是 LINQ to ...
    • 运行库中的对象具有唯一标识。引用同一对象的两个变量实际上是引用此对象的同一实例。你更改一个变量后,可以通过另一个变量看到这些更改。
    • 关系数据库表中的行不具有唯一标识。由于每一行都具有唯一的主键,因此任何两行都不会共用同一键值。

    实际上,通常我们是将数据从数据库中提取出来放入另一层中,应用程序在该层对数据进行处理。这就是 LINQ to SQL 支持的模型。将数据作为行从数据库中提取出来时,你不期望表示相同数据的两行实际上对应于相同的行实例。如果您查询特定客户两次,您将获得两行数据。每一行包含相同的信息。

    对于对象。你期望在你反复向 DataContext 索取相同的信息时,它实际上会为你提供同一对象实例。你将它们设计为层次结构或关系图。你希望像检索实物一样检索它们,而不希望仅仅因为你多次索要同一内容而收到大量的复制实例。

    在 LINQ to SQL 中,DataContext 管理对象标识。只要你从数据库中检索新行,该行就会由其主键记录到标识表中,并且会创建一个新的对象。只要您检索该行,就会将原始对象实例传递回应用程序。通过这种方式,DataContext 将数据库看到的标识(即主键)的概念转换成相应语言看到的标识(即实例)的概念。应用程序只看到处于第一次检索时的状态的对象。新数据如果不同,则会被丢弃。

    LINQ to SQL 使用此方法来管理本地对象的完整性,以支持开放式更新。由于在最初创建对象后唯一发生的更改是由应用程序做出的,因此应用程序的意向是很明确的。如果在中间阶段外部某一方做了更改,则在调用 SubmitChanges() 时会识别出这些更改。

    以上来自MSDN,的确,看了有点“正规”,下面我用两个例子说明一下。

    对象缓存

    在第一个示例中,如果我们执行同一查询两次,则每次都会收到对内存中同一对象的引用。很明显,cust1和cust2是同一个对象引用。

    Customer cust1 = db.Customers.First(c => c.CustomerID == "BONAP");
    Customer cust2 = db.Customers.First(c => c.CustomerID == "BONAP");

    下面的示例中,如果您执行返回数据库中同一行的不同查询,则您每次都会收到对内存中同一对象的引用。cust1和cust2是同一个对象引用,但是数据库查询了两次。

    Customer cust1 = db.Customers.First(c => c.CustomerID == "BONAP");
    Customer cust2 = (
        from o in db.Orders
        where o.Customer.CustomerID == "BONAP"
        select o )
        .First()
        .Customer;
    本文摘自:http://www.cnblogs.com/lyj/archive/2008/03/10/1098828.html
    展开全文
  • [*]对象标识 [/list] 运行库中的对象具有唯一标识。引用同一对象的两个变量实际上是引用此对象的同一实例。你更改一个变量后,可以通过另一个变量看到这些更改。 关系数据库表中的行具有唯一标识。由于每一行...
    [list]
    [*]对象标识
    [/list]
    运行库中的对象具有唯一标识。引用同一对象的两个变量实际上是引用此对象的同一实例。你更改一个变量后,可以通过另一个变量看到这些更改。
    关系数据库表中的行不具有唯一标识。由于每一行都具有唯一的主键,因此任何两行都不会共用同一键值。
    实际上,通常我们是将数据从数据库中提取出来放入另一层中,应用程序在该层对数据进行处理。这就是 LINQ to SQL 支持的模型。将数据作为行从数据库中提取出来时,你不期望表示相同数据的两行实际上对应于相同的行实例。如果您查询特定客户两次,您将获得两行数据。每一行包含相同的信息。

    对于对象。你期望在你反复向 DataContext 索取相同的信息时,它实际上会为你提供同一对象实例。你将它们设计为层次结构或关系图。你希望像检索实物一样检索它们,而不希望仅仅因为你多次索要同一内容而收到大量的复制实例。

    在 LINQ to SQL 中,DataContext 管理对象标识。只要你从数据库中检索新行,该行就会由其主键记录到标识表中,并且会创建一个新的对象。只要您检索该行,就会将原始对象实例传递回应用程序。通过这种方式,DataContext 将数据库看到的标识(即主键)的概念转换成相应语言看到的标识(即实例)的概念。应用程序只看到处于第一次检索时的状态的对象。新数据如果不同,则会被丢弃。

    LINQ to SQL 使用此方法来管理本地对象的完整性,以支持开放式更新。由于在最初创建对象后唯一发生的更改是由应用程序做出的,因此应用程序的意向是很明确的。如果在中间阶段外部某一方做了更改,则在调用 SubmitChanges() 时会识别出这些更改。

    以上来自MSDN,的确,看了有点“正规”,下面我用两个例子说明一下。
    [list]
    [*]对象缓存
    [/list]

    在第一个示例中,如果我们执行同一查询两次,则每次都会收到对内存中同一对象的引用。很明显,cust1和cust2是同一个对象引用。

    Customer cust1 = db.Customers.First(c => c.CustomerID == "BONAP");Customer cust2 = db.Customers.First(c => c.CustomerID == "BONAP");下面的示例中,如果您执行返回数据库中同一行的不同查询,则您每次都会收到对内存中同一对象的引用。cust1和cust2是同一个对象引用,但是数据库查询了两次。

    Customer cust1 = db.Customers.First(c => c.CustomerID == "BONAP");Customer cust2 = ( from o in db.Orders where o.Customer.CustomerID == "BONAP" select o ) .First() .Customer;

    [list]
    [*]对象加载
    [/list]

    延迟加载
    在查询某对象时,实际上你只查询该对象。不会同时自动获取这个对象。这就是延迟加载。

    例如,您可能需要查看客户数据和订单数据。你最初不一定需要检索与每个客户有关的所有订单数据。其优点是你可以使用延迟加载将额外信息的检索操作延迟到你确实需要检索它们时再进行。请看下面的示例:检索出来CustomerID,就根据这个ID查询出OrderID。

    var custs = from c in db.Customers where c.City == "Sao Paulo" select c;//上面的查询句法不会导致语句立即执行,仅仅是一个描述性的语句,只有需要的时候才会执行它foreach (var cust in custs){ foreach (var ord in cust.Orders) { //同时查看客户数据和订单数据 }}语句描述:原始查询未请求数据,在所检索到各个对象的链接中导航如何能导致触发对数据库的新查询。
    [list]
    [*]预先加载:LoadWith 方法
    [/list]

    你如果想要同时查询出一些对象的集合的方法。LINQ to SQL 提供了 DataLoadOptions用于立即加载对象。方法包括:
    LoadWith 方法,用于立即加载与主目标相关的数据。
    AssociateWith 方法,用于筛选为特定关系检索到的对象。

    使用 LoadWith方法指定应同时检索与主目标相关的哪些数据。例如,如果你知道你需要有关客户的订单的信息,则可以使用 LoadWith 来确保在检索客户信息的同时检索订单信息。使用此方法可仅访问一次数据库,但同时获取两组信息。
    在下面的示例中,我们通过设置DataLoadOptions,来指示DataContext在加载Customers的同时把对应的Orders一起加 载,在执行查询时会检索位于Sao Paulo的所有 Customers 的所有 Orders。这样一来,连续访问 Customer 对象的 Orders 属性不会触发新的数据库查询。在执行时生成的SQL语句使用了左连接。

    NorthwindDataContext db = new NorthwindDataContext();DataLoadOptions ds = new DataLoadOptions();ds.LoadWith<Customer>(p => p.Orders);db.LoadOptions = ds;var custs = ( from c in db2.Customers where c.City == "Sao Paulo" select c);foreach (var cust in custs){ foreach (var ord in cust.Orders) { Console.WriteLine("CustomerID {0} has an OrderID {1}.", cust.CustomerID, ord.OrderID); }}语句描述:在原始查询过程中使用 LoadWith 请求相关数据,以便稍后在检索到的各个对象中导航时不需要对数据库进行额外的往返。
    [list]
    [*]延迟加载:AssociateWith方法
    [/list]

    使用 AssociateWith 方法指定子查询以限制检索的数据量。
    在下面的示例中,AssociateWith 方法将检索的 Orders 限制为当天尚未装运的那些 Orders。如果没有此方法,则会检索所有 Orders,即使只需要一个子集。但是生成SQL语句会发现生成了很多SQL语句。

    NorthwindDataContext db2 = new NorthwindDataContext();DataLoadOptions ds = new DataLoadOptions();ds.AssociateWith<Customer>( p => p.Orders.Where(o => o.ShipVia > 1));db2.LoadOptions = ds;var custs = from c in db2.Customers where c.City == "London" select c;foreach (var cust in custs){ foreach (var ord in cust.Orders) { foreach (var orderDetail in ord.OrderDetails) { //可以查询出cust.CustomerID, ord.OrderID, ord.ShipVia, //orderDetail.ProductID, orderDetail.Product.ProductName } }}语句描述:原始查询未请求数据,在所检索到各个对象的链接中导航如何以触发对数据库的新查询而告终。此示例还说明在延迟加载关系对象时可以使用 Assoicate With 筛选它们。
    [list]
    [*]预先加载:LoadWith方法和Associate With方法
    [/list]
    这个例子说明:使用LoadWith方法来确保在检索客户信息的同时检索订单信息,在检索订单信息的同时检索订单详细信息, 仅仅访问一次数据库。即可以在一个查询中检索许多对象。使用Associate With方法来限制订单详细信息的排序规则。

    NorthwindDataContext db2 = new NorthwindDataContext();DataLoadOptions ds = new DataLoadOptions();ds.LoadWith<Customer>(p => p.Orders);ds.LoadWith<Order>(p => p.OrderDetails);ds.AssociateWith<Order>( p => p.OrderDetails.OrderBy(o => o.Quantity));db2.LoadOptions = ds;var custs = ( from c in db2.Customers where c.City == "London" select c);foreach (var cust in custs){ foreach (var ord in cust.Orders) { foreach (var orderDetail in ord.OrderDetails) { //查询cust.CustomerID, ord.OrderID //orderDetail.ProductID, orderDetail.Quantity } }}语句描述:在原始查询过程中使用 LoadWith 请求相关数据,以便稍后在检索到的各个对象中导航时此示例还说明在急切加载关系对象时可以使用 Assoicate With 对它们进行排序。

    [list]
    [*]加载重写
    [/list]

    这个例子在Category类里提供了一个LoadProducts分部方法。当产品的类别被加载的时候,就直接优先调用了LoadProducts方法来查询没有货源的产品。

    private IEnumerable<Product> LoadProducts(Category category){ //在执行LINQ to SQL的时候,这个LoadProducts分部方法 //优先加载执行,这里用存储过程也可以. return this.Products .Where(p => p.CategoryID == category.CategoryID) .Where(p => !p.Discontinued);}执行下面的查询时,利用上面方法返回的数据进行下面的操作:

    NorthwindDataContext db2 = new NorthwindDataContext();DataLoadOptions ds = new DataLoadOptions();ds.LoadWith<Category>(p => p.Products);db2.LoadOptions = ds;var q = ( from c in db2.Categories where c.CategoryID < 3 select c);foreach (var cat in q){ foreach (var prod in cat.Products) { //查询cat.CategoryID, prod.ProductID }}语句描述:重写 Category 类中的分部方法 LoadProducts。加载某种类别的产品时,调用 LoadProducts 以加载此类别中未停产的产品。
    展开全文
  • 对象标识 运行库中的对象具有唯一标识。引用同一对象的两个变量实际上是引用此对象的同一实例。你更改一个变量后,可以通过另一个变量看到这些更改。关系数据库表中的行具有唯一标识。由于每一行都具有唯一的...

    对象标识

    • 运行库中的对象具有唯一标识。引用同一对象的两个变量实际上是引用此对象的同一实例。你更改一个变量后,可以通过另一个变量看到这些更改。
    • 关系数据库表中的行不具有唯一标识。由于每一行都具有唯一的主键,因此任何两行都不会共用同一键值。

    实际上,通常我们是将数据从数据库中提取出来放入另一层中,应用程序在该层对数据进行处理。这就是 LINQ to SQL 支持的模型。将数据作为行从数据库中提取出来时,你不期望表示相同数据的两行实际上对应于相同的行实例。如果您查询特定客户两次,您将获得两行数据。每一行包含相同的信息。

    对于对象。你期望在你反复向 DataContext 索取相同的信息时,它实际上会为你提供同一对象实例。你将它们设计为层次结构或关系图。你希望像检索实物一样检索它们,而不希望仅仅因为你多次索要同一内容而收到大量的复制实例。

    在 LINQ to SQL 中,DataContext 管理对象标识。只要你从数据库中检索新行,该行就会由其主键记录到标识表中,并且会创建一个新的对象。只要您检索该行,就会将原始对象实例传递回应用程序。通过这种方式,DataContext 将数据库看到的标识(即主键)的概念转换成相应语言看到的标识(即实例)的概念。应用程序只看到处于第一次检索时的状态的对象。新数据如果不同,则会被丢弃。

    LINQ to SQL 使用此方法来管理本地对象的完整性,以支持开放式更新。由于在最初创建对象后唯一发生的更改是由应用程序做出的,因此应用程序的意向是很明确的。如果在中间阶段外部某一方做了更改,则在调用 SubmitChanges() 时会识别出这些更改。

    以上来自MSDN,的确,看了有点“正规”,下面我用两个例子说明一下。

    对象缓存

    在第一个示例中,如果我们执行同一查询两次,则每次都会收到对内存中同一对象的引用。很明显,cust1和cust2是同一个对象引用。

    Customer cust1 = db.Customers.First(c => c.CustomerID == "BONAP");
    Customer cust2 = db.Customers.First(c => c.CustomerID == "BONAP");

    下面的示例中,如果您执行返回数据库中同一行的不同查询,则您每次都会收到对内存中同一对象的引用。cust1和cust2是同一个对象引用,但是数据库查询了两次。

    Customer cust1 = db.Customers.First(c => c.CustomerID == "BONAP");
    Customer cust2 = (
        from o in db.Orders
        where o.Customer.CustomerID == "BONAP"
        select o )
        .First()
        .Customer;

    对象加载

    延迟加载

    在查询某对象时,实际上你只查询该对象。不会同时自动获取这个对象。这就是延迟加载。

    例如,您可能需要查看客户数据和订单数据。你最初不一定需要检索与每个客户有关的所有订单数据。其优点是你可以使用延迟加载将额外信息的检索操作延迟到你确实需要检索它们时再进行。请看下面的示例:检索出来CustomerID,就根据这个ID查询出OrderID。

    var custs =
         from c in db.Customers
         where c.City == "Sao Paulo"
         select c;
    //上面的查询句法不会导致语句立即执行,仅仅是一个描述性的语句,
    只有需要的时候才会执行它
    foreach (var cust in custs)
    {
        foreach (var ord in cust.Orders)
        {
            //同时查看客户数据和订单数据
        }
    }

    语句描述:原始查询未请求数据,在所检索到各个对象的链接中导航如何能导致触发对数据库的新查询。

    预先加载:LoadWith 方法

    你如果想要同时查询出一些对象的集合的方法。LINQ to SQL 提供了 DataLoadOptions用于立即加载对象。方法包括:
    LoadWith 方法,用于立即加载与主目标相关的数据。
    AssociateWith 方法,用于筛选为特定关系检索到的对象。

    使用 LoadWith方法指定应同时检索与主目标相关的哪些数据。例如,如果你知道你需要有关客户的订单的信息,则可以使用 LoadWith 来确保在检索客户信息的同时检索订单信息。使用此方法可仅访问一次数据库,但同时获取两组信息。
    在下面的示例中,我们通过设置DataLoadOptions,来指示DataContext在加载Customers的同时把对应的Orders一起加载,在执行查询时会检索位于Sao Paulo的所有 Customers 的所有 Orders。这样一来,连续访问 Customer 对象的 Orders 属性不会触发新的数据库查询。在执行时生成的SQL语句使用了左连接。

    NorthwindDataContext db = new NorthwindDataContext();
    DataLoadOptions ds = new DataLoadOptions();
    ds.LoadWith<Customer>(p => p.Orders);
    db.LoadOptions = ds;
    var custs = (
         from c in db2.Customers
         where c.City == "Sao Paulo"
         select c);
    foreach (var cust in custs)
    {
        foreach (var ord in cust.Orders)
        {
            Console.WriteLine("CustomerID {0} has an OrderID {1}.",
                cust.CustomerID,
                ord.OrderID);
        }
    }

    语句描述:在原始查询过程中使用 LoadWith 请求相关数据,以便稍后在检索到的各个对象中导航时不需要对数据库进行额外的往返。

    延迟加载:AssociateWith方法

    使用 AssociateWith 方法指定子查询以限制检索的数据量。
    在下面的示例中,AssociateWith 方法将检索的 Orders 限制为当天尚未装运的那些 Orders。如果没有此方法,则会检索所有 Orders,即使只需要一个子集。但是生成SQL语句会发现生成了很多SQL语句。

    NorthwindDataContext db2 = new NorthwindDataContext();
    DataLoadOptions ds = new DataLoadOptions();
    ds.AssociateWith<Customer>(
         p => p.Orders.Where(o => o.ShipVia > 1));
    db2.LoadOptions = ds;
    var custs =
         from c in db2.Customers
         where c.City == "London"
         select c;
    foreach (var cust in custs)
    {
        foreach (var ord in cust.Orders)
        {
            foreach (var orderDetail in ord.OrderDetails)
            {
               //可以查询出cust.CustomerID, ord.OrderID, ord.ShipVia,
               //orderDetail.ProductID, orderDetail.Product.ProductName
            }
        }
    }

    语句描述:原始查询未请求数据,在所检索到各个对象的链接中导航如何以触发对数据库的新查询而告终。此示例还说明在延迟加载关系对象时可以使用 Assoicate With 筛选它们。

    预先加载:LoadWith方法和Associate With方法

    这个例子说明:使用LoadWith方法来确保在检索客户信息的同时检索订单信息,在检索订单信息的同时检索订单详细信息, 仅仅访问一次数据库。即可以在一个查询中检索许多对象。使用Associate With方法来限制订单详细信息的排序规则。

    NorthwindDataContext db2 = new NorthwindDataContext();
    DataLoadOptions ds = new DataLoadOptions();
    ds.LoadWith<Customer>(p => p.Orders);
    ds.LoadWith<Order>(p => p.OrderDetails);
    ds.AssociateWith<Order>(
         p => p.OrderDetails.OrderBy(o => o.Quantity));
    db2.LoadOptions = ds;
    var custs = (
         from c in db2.Customers
         where c.City == "London"
         select c);
    foreach (var cust in custs)
    {
        foreach (var ord in cust.Orders)
        {
            foreach (var orderDetail in ord.OrderDetails)
            {
               //查询cust.CustomerID, ord.OrderID
               //orderDetail.ProductID, orderDetail.Quantity
            }
        }
    }

    语句描述:在原始查询过程中使用 LoadWith 请求相关数据,以便稍后在检索到的各个对象中导航时此示例还说明在急切加载关系对象时可以使用 Assoicate With 对它们进行排序。

    加载重写

    这个例子在Category类里提供了一个LoadProducts分部方法。当产品的类别被加载的时候,就直接优先调用了LoadProducts方法来查询没有货源的产品。

    private IEnumerable<Product> LoadProducts(Category category)
    {
        //在执行LINQ to SQL的时候,这个LoadProducts分部方法
        //优先加载执行,这里用存储过程也可以. 
        return this.Products
            .Where(p => p.CategoryID == category.CategoryID)
            .Where(p => !p.Discontinued);
    }

    执行下面的查询时,利用上面方法返回的数据进行下面的操作:

    NorthwindDataContext db2 = new NorthwindDataContext();
    DataLoadOptions ds = new DataLoadOptions();
    ds.LoadWith<Category>(p => p.Products);
    db2.LoadOptions = ds;
    var q = (
         from c in db2.Categories
         where c.CategoryID < 3
         select c);
    foreach (var cat in q)
    {
        foreach (var prod in cat.Products)
        {
           //查询cat.CategoryID, prod.ProductID
        }
    }

    语句描述:重写 Category 类中的分部方法 LoadProducts。加载某种类别的产品时,调用 LoadProducts 以加载此类别中未停产的产品。

    本系列链接:LINQ体验系列文章导航

    LINQ推荐资源

    LINQ专题:http://kb.cnblogs.com/zt/linq/ 关于LINQ方方面面的入门、进阶、深入的文章。
    LINQ小组:http://space.cnblogs.com/group/linq/ 学习中遇到什么问题或者疑问提问的好地方。

    展开全文
  • 对象标识 运行库中的对象具有唯一标识。引用同一对象的两个变量实际上 是引用此对象的同一实例。你更改一个变量后,可以通过另一个变量看到这些更 改。 关系数据库表中的行具有唯一标识。由于每一行都具有...
  • 运行库中的对象具有唯一标识。引用同一对象的两个变量实际上是引用此对象的同一实例。你更改一个变量后,可以通过另一个变量看到这些更改。 关系数据库表中的行具有唯一标识。由于每一行都具有唯一的主键,因此...
  • 对象标识运行库中的对象具有唯一标识。引用同一对象的两个变量实际上是引用此对象的同一实例。你更改一个变量后,可以通过另一个变量看到这些更改。 关系数据库表中的行具有唯一标识。由于每一行都具有唯一的主键...
  • vue生成uuid唯一标识

    千次阅读 2020-05-08 20:01:14
    需要向后端传一个唯一字段作为标识,当多次提交内容不变的时候,标识不改,如果有内容改变,则标识改变,借鉴了一位大佬的uuid代码,但是太不好意思忘记是谁了,vue 使用watch监听对象的变化,如果变了调用一遍uuid...
  • 为什么需要唯一ID「ID」—又称「标识符」(identifier),是一个可以唯一识别一个对象或者物体的名称,被识别的对象可能是一些想法、物理上可数的对象或者物理上的可数物质。在传统单机服务的情况下,往往通过一个...
  • 使用领域模型和行数据入口的时候,就要使用标识域,因为这两个对象代表的是唯一存在的那个数据记录。事务脚本、表模块、表数据入口等就需要这个映射。 public abstract class DomainObj { public string Id {...
  • Unity3d获取IOS设备唯一标识,以及IDFA

    万次阅读 2015-09-02 18:57:32
    之前苹果设备上获取唯一标识符,可以通过获取Mac地址。...新建个脚本,然后绑定到一个对象上,脚本代码如下,这片代码我就多说了,懂得自己 去看下IOS和Unity的互调。弄完后导出IOS工程。 using Unity
  • - 身份:每个对象都有唯一的身份标识可以认为是该对象的内存地址。可以通过内建函数 id()来得到。 - 类型:对象的类型决定了对象可以进行什么样的操作,保存什么样的值。可以通过内建函数type()来得到。 - 值:...
  • Java编程是一种通用的面向对象的编程语言,旨在为诸如电视,VCR,烤面包机等消费电子设备开发软件。Java编程语言是一种平台无关的语言,这意味着它受任何特定硬件或操作系统的约束。它保证用户“写一次,就可以在...
  • 唯一标识:用于标识对象的在内存中唯一,它在对象创建之后就不会再,函数可以查看对象唯一标识 id()类型:决定了该对象支持哪些操作,不同类型的对象支持的操作就一样,比如列表可以有长度属性,而整数没有同样...
  • 标识指的是对象的内存地址,每个对象唯一的地址,通过id内建函数可以求出地址;值从字面上看是对象的内容,但是应该理解为对内容的绑定关系。绑定也有说成引用、指向。对象一旦被创建,它的类型和标识是不变的,...
  • 对象

    2017-08-22 20:34:00
    是一种数据,用来在OC中唯一标识一个类(一种编号) 该种数据的数据类型是Class 定义:Class c 实例方法: 获取类对象: 类对象对象可以获取 :** [student class] / [TRStudent class]** // Class c = ...
  • 第一章 对象导论

    2017-04-06 02:54:24
    所谓的“类型”是指“所抽象的是什么?”对象具有状态、行为和标识。...标识:每个对象可以唯一地与其他对象区分开来,例如每个对象在内存都有一个唯一的地址(标识不一定是内存地址,也可以用其他方式来标识)。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 797
精华内容 318
关键字:

对象标识可以不唯一