性能和代码重现之间的平衡

Question

我目前正在开发一个项目，因为该项目构建了许多代码行，因此我尝试采用一些简单的方法并开始使用一些更智能的方法使代码可以重用。 所以我需要连接到Sql Server：

_{（它可能是我正在学习的任何其他任务，而我的代码我知道所有可用的.Net内置专用类）}

我真的需要的是： SqlCommand，SqlDataReader（＆amp; SqlConnection）以及用于返回数据的相应容器对象 通常我使用List<dictionary<string, object>>进行数据库测试 所以到现在为止我认为这是非常小的。 但是，我说啊，这是连接到SQL并获取一些行集的好方法 然后我决定这还不够，因为还有一些其他类型的返回数据，所以让我们做一些替代方案以涵盖更多选项，实际上让我们涵盖所有可用的场景，然后我想出一个充满“模型”覆盖的类所有可用数据格式，单记录多行数据集等。 但这并不是全部从.NET中读取sql server的两个主要选项 例如SqlDataReader和SqlDataAdapter。所以我也会介绍这些选项，但等等，还有我可以使用的神奇词汇，如存储过程和纯文本命令，所以让我们创建一个类，它将包含一些定义存储过程的结构，然后是存储过程参数，让我们可以轻松地将存储过程作为一个对象进行调用，以便以后进行单行调用，并且我们有一个存储过程对象......

现在，如果我会在这里停下来因为这只是一个开始，在那个兔子洞里还有更多......而且即使不是最好的例子，因为创建的对象有很好的理由存在，除非你想更有效地编码它，否则你不会创建那些额外的类和对象 通过这种行为以及在“每日”基础上覆盖的更多任务，我开始看到有一种模式导致一个巨大的.Cs文件，其中包含大约10个名称空间，每个名称空间包含数十个类和函数。 问题是你如何决定何时使用最少的代码，何时你放手并且不关心很多因为嘿，工作站就是说... 8核I7机器没有太大的区别，所以让我们担心编码的简易性。

你把红线放在哪里？

编辑以下代码不是用于代码审核目的，只是为了显示应用程序的规模及其可能带来的性能影响。**

这只是数据对象工厂的核心，大约是该类的1/3，是其他任务中的一小部分。

public class Inventory
{
    public class DataCariers
    {
        public class DbDataCar
        {
            public Prototypes.DataCarPrototypes.CarTypeMeta CarierSpec { get; set; }
            public AlsDataCariers.Inventory.Compartments.DataCarCompartment Trunk { get; set; }
            public string CarierName { get; private set; }
            public DbDataCar(AlsTransMods.Direction bsDir, AlsTransMods.CarSize bsCs, AlsTransMods.useCar bsFamType, Compartments.DataCarCompartment bsTrunk)
            {
                this.CarierSpec = new Prototypes.DataCarPrototypes.CarTypeMeta()
                {
                    CarDirection = bsDir,
                    carOfSize = bsCs,
                    CarFamilySelected = bsFamType
                };
                this.Trunk = bsTrunk;
                this.Trunk.Value = new object();
                this.Trunk.compTypeMeta.CompartmentParent = this.GetType();

            }

            public DbDataCar(Prototypes.DataCarPrototypes.CarTypeMeta bsCarierSpec, Compartments.DataCarCompartment bsTrunk)
            {
                this.CarierSpec = bsCarierSpec;
                this.Trunk = bsTrunk;
                this.Trunk.Value = new object();
                this.Trunk.compTypeMeta.CompartmentParent = this.GetType();

            }
            internal void SetTunk(string CsvVal)
            {
                //this.Trunk = new AlsDataCariers.Inventory.Compartments.GenericsDataCarCompartment.Singles(CsvVal);
                if (this.CarierSpec.CarDirection == AlsTransMods.Direction.In)
                {
                    // new Compartments.MultipleRowsTabedMultipleRecordsCompartmnet(new prototypesFactory.DataCarPrototypes.selectionsTypeCreator(prototypesFactory.DataCarPrototypes.SelectionMode.selectionMultyRow).SelectedSelectionType);
                }
                else this.Trunk.Value = new Csv() { val = CsvVal };
            }
        }


        public class GenericDbDataCar : DbDataCar
        {
            public GenericDbDataCar(AlsTransMods.Direction bsDir, AlsTransMods.CarSize bsCs, AlsTransMods.useCar bsFamType, Compartments.DataCarCompartment bsTrunk)
                : base(bsDir, bsCs, bsFamType, bsTrunk)
            {
                this.CarierSpec = new Prototypes.DataCarPrototypes.CarTypeMeta();
                this.CarierSpec.CarDirection = bsDir;
                this.CarierSpec.carOfSize = bsCs;
                this.CarierSpec.CarFamilySelected = bsFamType;
                this.CarierSpec.CarOfType = this.GetType();

                base.CarierSpec = this.CarierSpec;

                //this.Trunk = this.TrunkCreate();
                //base.Trunk = this.Trunk;
            }

            public GenericDbDataCar(Prototypes.DataCarPrototypes.CarTypeMeta bsCarierSpec, Compartments.DataCarCompartment bsTrunk)
                : base(bsCarierSpec, bsTrunk)
            {
                this.CarierSpec.CarOfType = this.GetType();
                base.CarierSpec = this.CarierSpec;
            }

        }
        public class TabularDbDataCar : DbDataCar
        {
            public TabularDbDataCar(AlsTransMods.Direction bsDir, AlsTransMods.CarSize bsCs, AlsTransMods.useCar bsFamType, Compartments.DataCarCompartment bsTrunk)
                : base(bsDir,  bsCs, bsFamType, bsTrunk)
            {
                this.CarierSpec = new Prototypes.DataCarPrototypes.CarTypeMeta();
                //this.CarierName = string.Concat(bsCs, bsFamType);
                this.CarierSpec.CarDirection = bsDir;
                this.CarierSpec.carOfSize = bsCs;
                this.CarierSpec.CarFamilySelected = bsFamType;
                this.CarierSpec.CarOfType = this.GetType();
                base.CarierSpec = this.CarierSpec;
            }
            public TabularDbDataCar(Prototypes.DataCarPrototypes.CarTypeMeta bsCarierSpec, Compartments.DataCarCompartment bsTrunk):base(bsCarierSpec, bsTrunk)
            {
                this.CarierSpec.CarOfType = this.GetType();

            }

        }

    }
    public class Compartments
    {
        public class DataCarCompartment
        {
            //private Prototypes.DataCarPrototypes.selectionsType selectionsType;

            public RobCs509b.MyModels.Prototypes.DataCarPrototypes.CompartmentMeta compTypeMeta{get; private set;}
            public DataCarCompartment(RobCs509b.MyModels.Prototypes.DataCarPrototypes.CompartmentMeta Bs_CompTypeMeta)
            {
                this.compTypeMeta = Bs_CompTypeMeta;
                this.compTypeMeta.CompartmentSeed = this.GetType();

            }
            public virtual object Value { get; set; }

        }

        public class TabularDataCarCompartment : DataCarCompartment
        {
            public TabularDataCarCompartment(Prototypes.DataCarPrototypes.CompartmentMeta compartmentMeta)
                : base(compartmentMeta)
            {
                base.compTypeMeta.CompartmentFamilyType = this.GetType();
            }

        }
        public class TabedSingleRecordComartment : TabularDataCarCompartment
        {
            public TabedSingleRecordComartment(Prototypes.DataCarPrototypes.CompartmentMeta compartmentMeta)
                : base(compartmentMeta)
            {
                base.compTypeMeta.CompartmentDeliverBaseType = this.GetType();
                this.Value = new DataColumn();
                base.compTypeMeta.CompartmentDeliverType = this.Value.GetType();
            }
            public new DataColumn Value;

        }
        public class TabedMultipleRecordsCompartment : TabularDataCarCompartment
        {
            public TabedMultipleRecordsCompartment(Prototypes.DataCarPrototypes.CompartmentMeta compartmentMeta)
                : base(compartmentMeta)
            {
               base.compTypeMeta.CompartmentDeliverBaseType= this.GetType();
            }

        }
        public class TabedSingleRowMultipleRecordsCompartment : TabedMultipleRecordsCompartment
        {
            public TabedSingleRowMultipleRecordsCompartment(Prototypes.DataCarPrototypes.CompartmentMeta compartmentMeta)
                : base(compartmentMeta)
            {
                base.compTypeMeta.CompartmentDeliverBaseType = this.GetType();

                base.compTypeMeta.CompartmentDeliverType = this.Value.GetType();
                base.Value = this.Value;
            }
            public new DataRow Value;
        }
        public class MultipleRowsTabedMultipleRecordsCompartmnet : TabedMultipleRecordsCompartment
        {
            public MultipleRowsTabedMultipleRecordsCompartmnet(Prototypes.DataCarPrototypes.CompartmentMeta compartmentMeta)
                : base(compartmentMeta)
            {
                base.compTypeMeta.CompartmentDeliverBaseType = this.GetType();
                this.Value = new DataTable();
                base.compTypeMeta.CompartmentDeliverType = this.Value.GetType();
                base.Value = this.Value;
            }
            public new DataTable Value;
        }
        public class MultipleRowsClonedTabedMultipleRecordsCompartmnet : TabedMultipleRecordsCompartment
        {
            public MultipleRowsClonedTabedMultipleRecordsCompartmnet(Prototypes.DataCarPrototypes.CompartmentMeta compartmentMeta)
                : base(compartmentMeta)
            {
                base.compTypeMeta.CompartmentDeliverBaseType = this.GetType();
                this.Value = new ClonedSchemaDtt("NotSet");
                base.compTypeMeta.CompartmentDeliverType = this.Value.GetType();
            }
            public new ClonedSchemaDtt Value;
        }


        public class GenericDataCarCompartment : DataCarCompartment
        {
            public GenericDataCarCompartment(Prototypes.DataCarPrototypes.CompartmentMeta compartmentMeta)
                : base(compartmentMeta)
            {
                base.compTypeMeta.CompartmentFamilyType = this.GetType();
            }

        }
        public class GenericSingelRecordCompartment : GenericDataCarCompartment
        {
            public GenericSingelRecordCompartment(Prototypes.DataCarPrototypes.CompartmentMeta compartmentMeta)
                : base(compartmentMeta)
            {

            }
        }
        public class GenericSingleCsv :GenericSingelRecordCompartment
        {
            public GenericSingleCsv(string CsvVal,Prototypes.DataCarPrototypes.CompartmentMeta compartmentMeta)
                : base(compartmentMeta)
            {
                this.Value = new Csv();
                this.Value.val = CsvVal;
            }
            public new Csv Value;
        }
        public class GenericMultipleRecordsCompartment : GenericDataCarCompartment
        {
            public GenericMultipleRecordsCompartment(Prototypes.DataCarPrototypes.CompartmentMeta compartmentMeta)
                : base(compartmentMeta)
            {

            }
                //public RepetablevaluesCollections RepeatbleCollNameVal;
                //public UniqCollectionNameval UniqCollNameVal;
        }
        public class GenericSingleRowMultipleRecordsCompartment3s: GenericMultipleRecordsCompartment
        {
            public GenericSingleRowMultipleRecordsCompartment3s(Prototypes.DataCarPrototypes.CompartmentMeta compartmentMeta)
                : base(compartmentMeta)
            {
                base.compTypeMeta.CompartmentDeliverBaseType = this.GetType();
                this.Value = new MyGenericObject3<string, string, string>("", "", "");
                base.compTypeMeta.CompartmentDeliverType = this.Value.GetType();
            }
            /// <summary>
            /// MyGenericObject3 (string,string,string) values.
            /// </summary>
            public new MyGenericObject3<string, string, string> Value;
        }
        public class GenericMultipleRowsMyGenericObj3DataCarCompartment:GenericMultipleRecordsCompartment
        {
            public GenericMultipleRowsMyGenericObj3DataCarCompartment (Prototypes.DataCarPrototypes.CompartmentMeta compartmentMeta)
                : base(compartmentMeta)
            {
                base.compTypeMeta.CompartmentDeliverBaseType = this.GetType();

                this.Value = new List<MyGenericObject3<string, string, string>>();
                                                base.compTypeMeta.CompartmentDeliverType = this.Value.GetType();
                base.Value = this.Value;
            }
            /// <summary>
            /// DbMagaZine (List MyGenereicObject3) valueType
            /// </summary>
            public new List<MyGenericObject3<string, string, string>> Value;
        }

    }

    public class CompartmentTypes
    {
        private CompartmentTypes creator;
        public CompartmentTypes ()
        {
   }
    }
}



public class Compartments
{
    public class Tabular :Inventory.CompartmentTypes
    {
            Type CompartmentOfFamilyType = typeof(System.ComponentModel.MarshalByValueComponent);
            Type CompartmnetOfType = typeof(Tabular);
    }
    public class Generic : Inventory.CompartmentTypes
    {
            Type CompartmnetOfType = typeof(Generic);
    }
}

Answer 1

你的问题是，有很多选择可以做同样的事情。 我的建议是使用最容易编程的技术，如果出于性能原因绝对必要，只能切换到较低级别的抽象。 并且不要比较简单案例的性能，而是考虑整个系统的性能和维护。 我在前实体框架中完成了数据库编程，并且正确地需要更多的专业知识和努力，因此我不建议今天这样做。

所以我按以下顺序推荐技术：

1. 实体框架纯
2. 具有特殊情况存储过程的实体框架
3. 数据集和手工制作的逻辑
4. 包含特殊情况存储过程的数据集
5. SqlDatareader，用于对整个表进行只读顺序访问