Question

这篇文章对我对C＃类的理解以及为什么它们比静态函数更有优势。

我正在尝试获取对象列表。列表中的每个对象代表表中的记录。这在静态函数中很容易实现。

使用课程，我能够按照以下方式完成：

调用例程：

ListOfBusinesses l = new ListOfBusinesses ();
List<Business> b = l.listBusinesses();

课程：

 public class Business
 {
    public string Bupk { get; set; }
    public string Bu_name { get; set; }

 }  

 public class ListOfBusinesses
 {
    public List<Business> listBusinesses()
    {

      List<Business> businesses = new List<Business>();
      businesses.Add(new Business("1", "Business Name 1"));
      businesses.Add(new Business("2", "Business Name 2"));

      return businesses;
    }
 }

我无法重写课程，以便可以用一行完成：

ListOfBusinesses l = new ListOfBusinesses();

在我看来，上面的ListofBusinesses类只不过是一个包含在没有属性的类中的静态函数，只是为了拥有一个类。

我试过了：

public class ListOfBusinesses
{
    List<Business> businesses;

    public List<Business> ListOfBusinesses()
    {

      List<Business> businesses = new List<Business>();
      businesses.Add(new Business("1", "Business Name 1"));
      businesses.Add(new Business("2", "Business Name 2"));

      return businesses;
    }
}

但收到编译错误“成员名称不能与封闭类型相同”。例如，我尝试使用构造函数，但我遗漏了一些东西。

在我误解了一段时间的地方，任何帮助都会启发我。

迈克·托马斯

Answer 1

我认为你混淆了静态函数，构造函数和工厂方法的概念。

静态功能

定义

这是一种无法访问（并且与之无关）类的this实例的方法。

实施例

public class BusinessHelper
{   
    public static List<Business> ListBusinesses()
    {

        List<Business> businesses = new List<Business>();
        businesses.Add(new Business("1", "Business Name 1"));
        businesses.Add(new Business("2", "Business Name 2"));

        return businesses;
    }
}

用法

使用类名调用静态方法，而不是类的实例。

List<Business> businesses = BusinessHelper.ListBusinesses();

构造函数：这是一个创建类this实例的方法。它没有返回值，并在实例化对象时调用。

实施例

public class BusinessList
{   
    public List<Business> TheList;

    public BusinessList()
    {    
        TheList = new List<Business>();
        TheList.Add(new Business("1", "Business Name 1"));
        TheList.Add(new Business("2", "Business Name 2"));   
    }
}

用法

创建对象的新实例。

BusinessList myBusinessList = new BusinessList();
businesses = myBusinessList.TheList;

工厂方法

定义

这是一个创建对象实例的方法，以某种方式实例化它，并返回对它的引用。

实施例

public class BusinessList
{   
    public List<Business> TheList;

    public static BusinessList BusinessListWithTwoCompanies()
    {
        BusinessList instance = new BusinessList();

        businesses = new List<Business>();
        businesses.Add(new Business("1", "Business Name 1"));
        businesses.Add(new Business("2", "Business Name 2"));

        return instance;
    }
}

用法

调用工厂方法而不是创建新对象。

BusinessList myBusinessList = BusinessList.BusinessListWithTwoCompanies();
businesses = myBusinessList.TheList;

另外要注意两件事：

您声明了businesses字段，但继续在businesses方法中实例化另一个名为ListOfBusinesses()的变量并将其返回。 businesses字段不会发生任何事情。小心变量范围。
您不能拥有与该类同名的成员（字段，属性或方法）。这是为构造函数保留的，它没有返回类型（参见上文）。这就是您收到编译器错误的原因。

Answer 2

不确定。而不是封装List<Business>，而是扩展它。然后你只需要在构造函数中添加它。

public class ListOfBusinesses : List<Business> {
    public ListOfBusinesses() : base() {
        Add(new Business("1", "Business Name 1"));
        Add(new Business("2", "Business Name 2"));
    }
}

使用它：

List<Business> l = new ListOfBusinesses();

Answer 3

对于所有OO语言，对象实例化基本相同。使用类而不是静态函数可以提供更大的灵活性，最终减少编码，尤其是在跟踪许多类似项目时。

想想书籍和图书馆。

如果您将该书作为对象类，那么您可以将其实例化以创建大量书籍并将其存储在您的库中。你已经实施的每本书都是独一无二的。如果您没有对其进行任何更改，则每个实例化的图书似乎都是原始图书的副本（尽管在较低级别，每本图书都有唯一的序列号）。它具有相同的封面，页数和内容，但您可以轻松地将您的名字写在一个副本中，从而使其与其他副本不同。

如果你让这本书成为静态的，那么虽然你不能创建单独的副本，但是你看的是同一本书，但是从不同的角度来看。如果您在其中写下您的名字，那么您的名字就会出现在本书的每个视图中。

我不会发布任何代码，因为在我输入的时候，很多其他代码已经为您的业务对象发布了代码示例。

Answer 4

您正在寻找工厂方法而不是构造函数。

Answer 5

您的编译器错误是因为您的类名是“ListOfBusinesses”，方法名称也是“ListOfBusinesses”。如果它是一个构造函数，这将没有问题，但由于你有一个返回类型，C＃认为你的意思是它是一个方法而不是一个构造函数。

至于获取业务列表，为什么不创建这样的类：

public class BusinessService {
   public List<Business> GetBusinesses() {
       // Build and return your list of objects here.
   }
}

然后使用它：

BusinessService service = new BusinessService();
List<Business> businesses = service.GetBusinesses();

Answer 6

你试图在构造函数

中返回与类不同的东西

public class ListOfBusinesses
{
    ...

    public List<Business> ListOfBusinesses()
    {
        ...

您无法在构造函数中指定返回类型，您需要：

public ListOfBusinesses()
{
    ...

正如迈克托马斯所说，如果你想要的话，你应该使用工厂。

Answer 7

问题是你正在使用保留字（new）来调用类的构造函数。

构造函数的语义是返回正在创建的类的实例，它遵循没有返回值且具有相同名称的类的规则。

如果不是这样的话，那么，如果你做任何new MyObject ...你怎么会（或编译器）应该知道返回的类型？

Answer 8

一般来说，除非ListOfBusinesses有一些List＆lt; Business＆gt;中没有的属性，否则不会创建ListOfBusinesses类。处理它的最简单方法是在Business类上使用静态方法，如下所示：

public class Business
{
    //Business class methods/properties/fields

    static List<Business> GetList()
    {
        List<Business> businesses = new List<Business>();
        businesses.Add(new Business("1", "Business Name 1"));
        businesses.Add(new Business("2", "Business Name 2"));
        return businesses;
    }
}

虽然这是一种直截了当的方式，但沿着这条道路前进的最终结果是将此方法从Business类重构为对象工厂，通常通过像NHibernate或Castle Windsor这样的ORM框架提供。

Answer 9

正如人们之前所说 - 你的语法不正确。 ListOfBusiness()是构造函数，不显式返回对象。它改为在ListOfBusiness的新实例上运行，并且应该处理任何必要的创建。

那就是说 - 如果创建List<Business>的方法很简单，那么绝对没有理由将它作为静态方法的一部分。您甚至可以在List上定义一个扩展方法，该方法获取一个空列表并填充它。这称为工厂模式，其中对象的方法或实例负责创建新实例。

如果存在需要跟踪的属性或状态，那么您希望将ListOfBusiness扩展到实例化类中的位置。如果每次调用List<Business>时都会更改，或者如果您需要添加新业务的位置，则ListOfBusiness类可能对此有用。

Answer 10

如果我没有错，你想访问一个数据库，并通过一个单行呼叫检索一个对象列表。

首先，您需要一个封装db访问并公开List方法的DAO类。在DAO中你可以使用NHibernate，Linq2XXX或任何你想要的（样本）

public class BusinessItem
{
    public string Code { get; set; }
    public string Description { get; set; }
}

public class BusinessItemsDAO
{
...
    public List<BusinessItem>   List()
    {
        // fake... should retrieve from db
        var list = new List<BusinessItem>();

        // returs the list
        return list;
    }
...
}

您的客户端代码只能调用

var listOfBusinessItems = new BusinessItemsDAO().List();

如果启用了Linq，则返回IQueryable而不是List。

不了解C＃中的对象实例化

10 个答案: