产品

最新推荐文章于 2024-08-31 14:37:30 发布
最新推荐文章于 2024-08-31 14:37:30 发布
阅读量487 收藏
点赞数
文章标签： dataset string null delete class insert
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zf_missyou/article/details/6689928
版权
 

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

namespace DAL
{
    public class Product
    {
        public Product()
        { }
        #region 成员方法

        public bool Exists(int P_ID)
        {
            StringBuilder strSql = new StringBuilder();
            strSql.Append("select count(*) from Product");
            strSql.Append("where P_ID="+ P_ID +"");
            return DbHelperOledb.Exists(strSql.ToString());
        }

        public int Count()
        {
            StringBuilder sql = new StringBuilder();
            sql.Append("select count(1) from product");
            return Convert.ToInt32(DbHelperOledb.ExecuteScalar(sql.ToString()));
        }

        public void Add(Model.Product model)
        {
            StringBuilder strSql = new StringBuilder();
            StringBuilder strSql1 = new StringBuilder();
            StringBuilder strSql2 = new StringBuilder();
            if (model.P_ID != null)
            {
                strSql1.Append("P_ID,");
                strSql2.Append("" + model.P_ID + ",");
            }
            if (model.P_Name != null)
            {
                strSql1.Append("P_Name,");
                strSql2.Append("'" + model.P_Name + "',");
            }
            if (model.P_ClassID != null)
            {
                strSql1.Append("P_ClassID,");
                strSql2.Append("" + model.P_ClassID + ",");
            }
            if (model.P_ParentID != null)
            {
                strSql1.Append("P_ParentID,");
                strSql2.Append("" + model.P_ParentID + ",");
            }
            if (model.P_ClassCode != null)
            {
                strSql1.Append("P_ClassCode,");
                strSql2.Append("'" + model.P_ClassCode + "',");
            }
            if (model.P_Show != null)
            {
                strSql1.Append("P_Show,");
                strSql2.Append("" + model.P_Show + ",");
            }
            if (model.P_Demo != null)
            {
                strSql1.Append("P_Demo,");
                strSql2.Append("'" + model.P_Demo + "',");
            }
            if (model.P_Content != null)
            {
                strSql1.Append("P_Content,");
                strSql2.Append("'" + model.P_Content + "',");
            }
            if (model.P_PhotoUrl != null)
            {
                strSql1.Append("P_PhotoUrl,");
                strSql2.Append("'" + model.P_PhotoUrl + "',");
            }
            if (model.P_PhotoUrlSmall != null)
            {
                strSql1.Append("P_PhotoUrlSmall,");
                strSql2.Append("'" + model.P_PhotoUrlSmall + "',");
            }
            if (model.P_Uptime != null)
            {
                strSql1.Append("P_Uptime,");
                strSql2.Append("'" + model.P_Uptime + "',");
            }
            strSql.Append("insert into Product(");
            strSql.Append(strSql1.ToString().Remove(strSql1.Length-1));
            strSql.Append(")");
            strSql.Append("values(");
            strSql.Append(strSql2.ToString().Remove(strSql2.Length-1));
            strSql.Append(")");
            DbHelperOledb.ExecuteSql(strSql.ToString());
        }

        public void Update(Model.Product model)
        {
            StringBuilder strSql = new StringBuilder();
            strSql.Append("update Product set ");
            if(model.P_Name!=null)
            {
                strSql.Append("P_Name='"+ model.P_Name +"',");
            }
            if (model.P_ClassID != null)
            {
                strSql.Append("P_ClassID=" + model.P_ClassID + ",");
            }
            if (model.P_ParentID != null)
            {
                strSql.Append("P_ParentID=" + model.P_ParentID + ",");
            }
            if (model.P_ClassCode != null)
            {
                strSql.Append("P_ClassCode='" + model.P_ClassCode + "',");
            }
            if (model.P_Show != null)
            {
                strSql.Append("P_Show=" + model.P_Show + ",");
            }
            if (model.P_Demo != null)
            {
                strSql.Append("P_Demo='" + model.P_Demo + "',");
            }
            if (model.P_Content != null)
            {
                strSql.Append("P_Content='" + model.P_Content + "',");
            }
            if (model.P_PhotoUrl != null)
            {
                strSql.Append("P_PhotoUrl='" + model.P_PhotoUrl + "',");
            }
            if (model.P_PhotoUrlSmall != null)
            {
                strSql.Append("P_PhotoUrlSmall='" + model.P_PhotoUrlSmall + "',");
            }
            if (model.P_Uptime != null)
            {
                strSql.Append("P_Uptime='" + model.P_Uptime + "',");
            }
            int n = strSql.ToString().LastIndexOf(",");
            strSql.Remove(n, 1);
            strSql.Append("where P_ID="+model.P_ID);//+" "
            DbHelperOledb.ExecuteSql(strSql.ToString());
        }

        public void Delete(int P_ID)
        {
            StringBuilder strSql = new StringBuilder();
            strSql.Append("delete from Product");
            strSql.Append(" where P_ID="+ P_ID +" ");
            DbHelperOledb.ExecuteSql(strSql.ToString());
        }

        public Model.Product GetModel(int P_ID)
        {
            StringBuilder strSql = new StringBuilder();
            strSql.Append("select  ");
            strSql.Append(" P_ID,P_Name,P_ClassID,P_ParentID,P_ClassCode,P_Show,P_Demo,P_Content,P_PhotoUrl,P_PhotoUrlSmall,P_Uptime ");
            strSql.Append(" from Product ");
            strSql.Append(" where P_ID=" + P_ID + " ");
            Model.Product model = new Model.Product();
            DataSet ds = DbHelperOledb.Query(strSql.ToString());
            if (ds.Tables[0].Rows.Count > 0)
            {
                if (ds.Tables[0].Rows[0]["P_ID"].ToString() != "")
                {
                    model.P_ID = int.Parse(ds.Tables[0].Rows[0]["P_ID"].ToString());
                }
                model.P_Name = ds.Tables[0].Rows[0]["P_Name"].ToString();
                if (ds.Tables[0].Rows[0]["P_ClassID"].ToString() != "")
                {
                    model.P_ClassID = int.Parse(ds.Tables[0].Rows[0]["P_ClassID"].ToString());
                }
                if (ds.Tables[0].Rows[0]["P_ParentID"].ToString() != "")
                {
                    model.P_ParentID = int.Parse(ds.Tables[0].Rows[0]["P_ParentID"].ToString());
                }
                model.P_ClassCode = ds.Tables[0].Rows[0]["P_ClassCode"].ToString();
                if (ds.Tables[0].Rows[0]["P_Show"].ToString() != "")
                {
                    model.P_Show = int.Parse(ds.Tables[0].Rows[0]["P_Show"].ToString());
                }
                model.P_Demo = ds.Tables[0].Rows[0]["P_Demo"].ToString();
                model.P_Content = ds.Tables[0].Rows[0]["P_Content"].ToString();
                model.P_PhotoUrl = ds.Tables[0].Rows[0]["P_PhotoUrl"].ToString();
                model.P_PhotoUrlSmall = ds.Tables[0].Rows[0]["P_PhotoUrlSmall"].ToString();
                if (ds.Tables[0].Rows[0]["P_Uptime"].ToString() != "")
                {
                    model.P_Uptime = DateTime.Parse(ds.Tables[0].Rows[0]["P_Uptime"].ToString());
                }
                return model;
            }
            else
            {
                return null;
            }
        }
        /// <summary>
        /// 获得数据列表
        /// </summary>
        public DataSet GetList(string strWhere)
        {
            StringBuilder strSql = new StringBuilder();
            strSql.Append("select [Product].*,[ProductClass].PC_ClassName ");
            strSql.Append(" FROM [Product] inner join [ProductClass] ");
            strSql.Append(" on [Product].P_ClassID=[ProductClass].PC_ID");
            if (strWhere.Trim() != "")
            {
                strSql.Append(" where " + strWhere);
            }
            strSql.Append(" order by P_ID desc");
            return DbHelperOledb.Query(strSql.ToString());
        }

        /// <summary>
        /// 获得符合查询条件的前Num记录
        /// </summary>
        /// <param name="num">要查询的条数</param>
        /// <param name="strWhere">查询条件</param>
        /// <returns></returns>
        public DataSet GetList(int num, string strWhere)
        {
            StringBuilder strSql = new StringBuilder();
            strSql.Append("select top " + num + " [Product].*,[ProductClass].PC_ClassName ");
            strSql.Append(" FROM [Product] inner join [ProductClass] ");
            strSql.Append(" on [Product].P_ClassID=[ProductClass].PC_ID");
            if (strWhere.Trim() != "")
            {
                strSql.Append(" where " + strWhere);
            }
            strSql.Append(" order by P_ID desc");
            return DbHelperOledb.Query(strSql.ToString());
        }

        #endregion
    }
}

 

 

 

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

namespace BLL
{
   public class Product
    {
       public Product()
       { }
       DAL.Product dal = new DAL.Product();

       public bool Exists(int P_ID)
       {
           return dal.Exists(P_ID);
       }

       public int Count()
       {
           return dal.Count();
       }

       /// <summary>
       /// 增加一条数据
       /// </summary>
       public void Add(Model.Product model)
       {
           dal.Add(model);
       }

       /// <summary>
       /// 更新一条数据
       /// </summary>
       public void Update(Model.Product model)
       {
           dal.Update(model);
       }

       /// <summary>
       /// 删除一条数据
       /// </summary>
       public void Delete(int P_ID)
       {

           dal.Delete(P_ID);
       }

       /// <summary>
       /// 得到一个对象实体
       /// </summary>
       public Model.Product GetModel(int P_ID)
       {

           return dal.GetModel(P_ID);
       }


       /// <summary>
       /// 获得数据列表
       /// </summary>
       public DataSet GetList(string strWhere)
       {
           return dal.GetList(strWhere);
       }

       /// <summary>
       /// 获得符合查询条件的前Num记录
       /// </summary>
       /// <param name="num">要查询的条数</param>
       /// <param name="strWhere">查询条件</param>
       /// <returns></returns>
       public DataSet GetList(int num, string strWhere)
       {
           return dal.GetList(num, strWhere);
       }

       public List<Model.Product> GetModelList(string strWhere)
       {
           DataSet ds = dal.GetList(strWhere);
           return DataTableToList(ds.Tables[0]);
       }

       public List<Model.Product> DataTableToList(DataTable dt)
       {
            List<Model.Product> modelList=new List<Model.Product>();
            int rowsCount = dt.Rows.Count;
           if(rowsCount>0)
           {
               Model.Product model;
               for (int n = 0; n < rowsCount;n++ )
               {
                   model = new Model.Product();
                   if (dt.Rows[n]["P_ID"].ToString() != "")
                   {
                       model.P_ID = int.Parse(dt.Rows[n]["P_ID"].ToString());
                   }
                   model.P_Name = dt.Rows[n]["P_Name"].ToString();
                   if (dt.Rows[n]["P_ClassID"].ToString() != "")
                   {
                       model.P_ClassID = int.Parse(dt.Rows[n]["P_ClassID"].ToString());
                   }
                   if (dt.Rows[n]["P_ParentID"].ToString() != "")
                   {
                       model.P_ParentID = int.Parse(dt.Rows[n]["P_ParentID"].ToString());
                   }
                   model.P_ClassCode = dt.Rows[n]["P_ClassCode"].ToString();
                   if (dt.Rows[n]["P_Show"].ToString() != "")
                   {
                       model.P_Show = int.Parse(dt.Rows[n]["P_Show"].ToString());
                   }
                   model.P_Demo = dt.Rows[n]["P_Demo"].ToString();
                   model.P_Content = dt.Rows[n]["P_Content"].ToString();
                   model.P_PhotoUrl = dt.Rows[n]["P_PhotoUrl"].ToString();
                   model.P_PhotoUrlSmall = dt.Rows[n]["P_PhotoUrlSmall"].ToString();
                   if (dt.Rows[n]["P_Uptime"].ToString() != "")
                   {
                       model.P_Uptime = DateTime.Parse(dt.Rows[n]["P_Uptime"].ToString());
                   }
                   modelList.Add(model);
               }

           }
           return modelList;
       }

       public DataSet GetAllList()
       {
           return GetList("");
       }
   }

}

 

 

 

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

namespace Model
{
    public class Product
    {
        public Product()
        { }

        #region Model
        private int? _p_id;
        private string _p_name;
        private int _p_classid;
        private int _p_parentid;
        private string _p_classcode;
        private int _p_show;
        private string _p_demo;
        private string _p_content;
        private string _p_photourl;
        private string _p_photourlsmall;
        private DateTime _p_uptime;

        public int? P_ID
        {
            set { _p_id = value; }
            get { return _p_id; }
        }
        /// <summary>
        ///
        /// </summary>
        public string P_Name
        {
            set { _p_name = value; }
            get { return _p_name; }
        }
        /// <summary>
        ///
        /// </summary>
        public int P_ClassID
        {
            set { _p_classid = value; }
            get { return _p_classid; }
        }
        /// <summary>
        ///
        /// </summary>
        public int P_ParentID
        {
            set { _p_parentid = value; }
            get { return _p_parentid; }
        }
        /// <summary>
        ///
        /// </summary>
        public string P_ClassCode
        {
            set { _p_classcode = value; }
            get { return _p_classcode; }
        }
        /// <summary>
        ///
        /// </summary>
        public int P_Show
        {
            set { _p_show = value; }
            get { return _p_show; }
        }
        /// <summary>
        ///
        /// </summary>
        public string P_Demo
        {
            set { _p_demo = value; }
            get { return _p_demo; }
        }
        /// <summary>
        ///
        /// </summary>
        public string P_Content
        {
            set { _p_content = value; }
            get { return _p_content; }
        }
        /// <summary>
        ///
        /// </summary>
        public string P_PhotoUrl
        {
            set { _p_photourl = value; }
            get { return _p_photourl; }
        }
        /// <summary>
        ///
        /// </summary>
        public string P_PhotoUrlSmall
        {
            set { _p_photourlsmall = value; }
            get { return _p_photourlsmall; }
        }
        /// <summary>
        ///
        /// </summary>
        public DateTime P_Uptime
        {
            set { _p_uptime = value; }
            get { return _p_uptime; }
        }
        #endregion
    }
}

 

 

 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using DBUtility;
using Model;
using System.Data;

namespace DAL
{
    public class ProductClass
    {
        public ProductClass()
        { }

        #region 成员方法

 

        ///<summary>
        ///是否存在该记录
        /// </summary>
        public bool Exists(int PC_Id)
        {
            StringBuilder strSql = new StringBuilder();
            strSql.Append("select count(*) from ProductClass");
            strSql.Append("where PC_Id=" + PC_Id + "");
            return DbHelperOledb.Exists(strSql.ToString());
        }

        ///<summary>
        ///增加一条数据
        /// </summary>
        public void Add(Model.ProductClass model)
        {
            StringBuilder strSql = new StringBuilder();
            StringBuilder strSql1 = new StringBuilder();
            StringBuilder strSql2 = new StringBuilder();
            if(model.PC_Id!=null)
            {
                strSql1.Append("PC_Id");
                strSql2.Append(""+ model.PC_Id +",");
            }
            if (model.PC_ClassName != null)
            {
                strSql1.Append("PC_ClassName,");
                strSql2.Append("'" + model.PC_ClassName + "',");
            }
            if (model.PC_ParentID != null)
            {
                strSql1.Append("PC_ParentID,");
                strSql2.Append("" + model.PC_ParentID + ",");
            }
            if (model.PC_ClassCode != null)
            {
                strSql1.Append("PC_ClassCode,");
                strSql2.Append("'" + model.PC_ClassCode + "',");
            }
            if (model.PC_ClassLevel != null)
            {
                strSql1.Append("PC_ClassLevel,");
                strSql2.Append("" + model.PC_ClassLevel + ",");
            }
            if (model.PC_ClassIsLock != null)
            {
                strSql1.Append("PC_ClassIsLock,");
                strSql2.Append("" + (model.PC_ClassIsLock ? 1 : 0) + ",");
            }
            strSql.Append("insert into ProductClass(");
            strSql.Append(strSql1.ToString().Remove(strSql1.Length - 1));
            strSql.Append(")");
            strSql.Append(" value(");
            strSql.Append(strSql2.ToString().Remove(strSql2.Length - 1));
            strSql.Append(")");
            DbHelperOledb.ExecuteSql(strSql.ToString());
        }

        /// <summary>
        /// 更新一条数据
        /// </summary>
        public void Update(Model.ProductClass model)
        {
            StringBuilder strSql = new StringBuilder();
            strSql.Append("update ProductClass set ");
            if (model.PC_Id != null)
            {
                strSql.Append("PC_Id=" + model.PC_Id + ",");
            }
            if (model.PC_ClassName != null)
            {
                strSql.Append("PC_ClassName='" + model.PC_ClassName + "',");
            }
            if (model.PC_ParentID != null)
            {
                strSql.Append("PC_ParentID=" + model.PC_ParentID + ",");
            }
            if (model.PC_ClassCode != null)
            {
                strSql.Append("PC_ClassCode='" + model.PC_ClassCode + "',");
            }
            if (model.PC_ClassLevel != null)
            {
                strSql.Append("PC_ClassLevel=" + model.PC_ClassLevel + ",");
            }
            if (model.PC_ClassIsLock != null)
            {
                strSql.Append("PC_ClassIsLock=" + (model.PC_ClassIsLock ? 1 : 0) + ",");
            }
            int n = strSql.ToString().LastIndexOf(",");
            strSql.Remove(n, 1);
            strSql.Append(" where PC_Id=" + model.PC_Id + " ");
            DbHelperOledb.ExecuteSql(strSql.ToString());
        }

        /// <summary>
        /// 删除一条数据
        /// </summary>
        public void Delete(int PC_Id)
        {
            StringBuilder strSql = new StringBuilder();
            strSql.Append("delete from ProductClass ");
            strSql.Append(" where PC_Id=" + PC_Id + " ");
            DbHelperOledb.ExecuteSql(strSql.ToString());
        }

        /// <summary>
        /// 得到一个对象实体
        /// </summary>
        public Model.ProductClass GetModel(int PC_Id)
        {
            StringBuilder strSql = new StringBuilder();
            strSql.Append("select  ");
            strSql.Append(" PC_Id,PC_ClassName,PC_ParentID,PC_ClassCode,PC_ClassLevel,PC_ClassIsLock ");
            strSql.Append(" from ProductClass ");
            strSql.Append(" where PC_Id=" + PC_Id + " ");
            Model.ProductClass model = new Model.ProductClass();
            DataSet ds = DbHelperOledb.Query(strSql.ToString());
            if (ds.Tables[0].Rows.Count > 0)
            {
                if (ds.Tables[0].Rows[0]["PC_Id"].ToString() != "")
                {
                    model.PC_Id = int.Parse(ds.Tables[0].Rows[0]["PC_Id"].ToString());
                }
                model.PC_ClassName = ds.Tables[0].Rows[0]["PC_ClassName"].ToString();
                if (ds.Tables[0].Rows[0]["PC_ParentID"].ToString() != "")
                {
                    model.PC_ParentID = int.Parse(ds.Tables[0].Rows[0]["PC_ParentID"].ToString());
                }
                model.PC_ClassCode = ds.Tables[0].Rows[0]["PC_ClassCode"].ToString();
                if (ds.Tables[0].Rows[0]["PC_ClassLevel"].ToString() != "")
                {
                    model.PC_ClassLevel = int.Parse(ds.Tables[0].Rows[0]["PC_ClassLevel"].ToString());
                }
                if (ds.Tables[0].Rows[0]["PC_ClassIsLock"].ToString() != "")
                {
                    if ((ds.Tables[0].Rows[0]["PC_ClassIsLock"].ToString() == "1") || (ds.Tables[0].Rows[0]["PC_ClassIsLock"].ToString().ToLower() == "true"))
                    {
                        model.PC_ClassIsLock = true;
                    }
                    else
                    {
                        model.PC_ClassIsLock = false;
                    }
                }
                return model;
            }
            else
            {
                return null;
            }
        }
        /// <summary>
        /// 获得数据列表
        /// </summary>
        public DataSet GetList(string strWhere)
        {
            StringBuilder strSql = new StringBuilder();
            strSql.Append("select PC_Id,PC_ClassName,PC_ParentID,PC_ClassCode,PC_ClassLevel,PC_ClassIsLock ");
            strSql.Append(" FROM ProductClass ");
            if (strWhere.Trim() != "")
            {
                strSql.Append(" where " + strWhere);
            }
            strSql.Append(" order by PC_ClassCode");
            return DbHelperOledb.Query(strSql.ToString());
        }

        #endregion

    }
}

 

 

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

namespace BLL
{
    public class ProductClass
    {
        private readonly DAL.ProductClass dal = new DAL.ProductClass();
        public ProductClass()
        { }

        #region 成员方法
        /// <summary>
        /// 是否存在该记录
        /// </summary>
        public bool Exists(int PC_Id)
        {
            return dal.Exists(PC_Id);
        }

        /// <summary>
        /// 增加一条数据
        /// </summary>
        public void Add(Model.ProductClass model)
        {
            dal.Add(model);
        }

        /// <summary>
        /// 更新一条数据
        /// </summary>
        public void Update(Model.ProductClass model)
        {
            dal.Update(model);
        }

        /// <summary>
        /// 删除一条数据
        /// </summary>
        public void Delete(int PC_Id)
        {

            dal.Delete(PC_Id);
        }

        /// <summary>
        /// 得到一个对象实体
        /// </summary>
        public Model.ProductClass GetModel(int PC_Id)
        {

            return dal.GetModel(PC_Id);
        }

 

        /// <summary>
        /// 获得数据列表
        /// </summary>
        public DataSet GetList(string strWhere)
        {
            return dal.GetList(strWhere);
        }
        /// <summary>
        /// 获得数据列表
        /// </summary>
        public List<Model.ProductClass> GetModelList(string strWhere)
        {
            DataSet ds = dal.GetList(strWhere);
            return DataTableToList(ds.Tables[0]);
        }

        /// <summary>
        /// 获得数据列表
        /// </summary>
        public List<Model.ProductClass> DataTableToList(DataTable dt)
        {
            List<Model.ProductClass> modelList = new List<Model.ProductClass>();
            int rowsCount = dt.Rows.Count;
            if(rowsCount > 0)
            {
                Model.ProductClass model;
                for (int n = 0; n < rowsCount; n++ )
                {
                    model = new Model.ProductClass();
                    if(dt.Rows[n]["PC_Id"].ToString() != "")
                    {
                        model.PC_Id = int.Parse(dt.Rows[n]["PC_Id"].ToString());
                    }
                    model.PC_ClassName = dt.Rows[n]["PC_ClassName"].ToString();
                    if(dt.Rows[n]["PC_ParengtID"].ToString() != "")
                    {
                        model.PC_ParentID = int.Parse(dt.Rows[n]["PC_ParentID"].ToString());
                    }
                    model.PC_ClassCode = dt.Rows[n]["PC_ClassCode"].ToString();
                    if (dt.Rows[n]["PC_ClassLevel"].ToString() != "")
                    {
                        model.PC_ClassLevel = int.Parse(dt.Rows[n]["PC_ClassLevel"].ToString());
                    }
                    if (dt.Rows[n]["PC_ClassIsLock"].ToString() != "")
                    {
                        if ((dt.Rows[n]["PC_ClassIsLock"].ToString() == "1") || (dt.Rows[n]["PC_ClassIsLock"].ToString().ToLower() == "true"))
                        {
                            model.PC_ClassIsLock = true;
                        }
                        else
                        {
                            model.PC_ClassIsLock = false;
                        }
                    }
                    modelList.Add(model);
                }
            }
            return modelList;
        }

        ///<summary>
        ///获得数据列表
        /// </summary>
        public DataSet GetAllList()
        {
            return GetList("");
        }
        #endregion

    }
}

 

 

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

namespace Model
{
    public class ProductClass
    {
        public ProductClass()
        { }

        #region Model
        private int? _pc_id;
        private string _pc_classname;
        private int _pc_parentid;
        private string _pc_classcode;
        private int _pc_classlevel;
        private bool _pc_classislock;

        public int? PC_Id
        {
            set { _pc_id = value; }
            get { return _pc_id; }
        }

      
        public string PC_ClassName
        {
            set { _pc_classname = value; }
            get { return _pc_classname; }
        }
       
        public int PC_ParentID
        {
            set { _pc_parentid = value; }
            get { return _pc_parentid; }
        }
       
        public string PC_ClassCode
        {
            set { _pc_classcode = value; }
            get { return _pc_classcode; }
        }
      
        public int PC_ClassLevel
        {
            set { _pc_classlevel = value; }
            get { return _pc_classlevel; }
        }
       
        public bool PC_ClassIsLock
        {
            set { _pc_classislock = value; }
            get { return _pc_classislock; }
        }
        #endregion
    }
}

 

 

zf_missyou
关注
电子产品设计的流程有哪些
LVCHUANGSHEJI的博客
12-13 1827
过程是指导工业外观设计的具体环节，主要包括产品市场需求分析、产品设计、产品原型设计、生产测试设计、大规模生产等方法和步骤。电子产品的关键部件包括印刷电路板、显示屏、开关电源、存储芯片、风扇、功能键、射频连接器等。聚氯乙烯是一种常见的塑料材料(PVC)，聚酯(PET)，聚氨酯(PU)和聚乙烯(PE)。1.产品定义：在设计电子产品之前，首先要明确目标客户、产品卖点、应用环境和产品定位。常用材料包括金属材料、塑料制品、夹层玻璃、瓷器、塑料和皮革制品。铜、铝、锌、镍、铁是重要的材料。
产品经理面试题自用
何少的博客
08-12 2680
单面： 面试那个公司时，要查一下这个公司的消息，并对该公司所处行业有个基本的了解和自己的看法。 答： 这个问题的问题大概率决定求职者是产品助理、产品经理、高级产品经理中的哪一个？ 也是其中一个场景。但是由于市场教育进程缓慢，线上教育只占整个教育市场的20%份额。疫情来临，对在线教育是一针强心剂，加剧了对整个市场的教育过程。因此在线教育也进入了下一个竞争白热化的阶段。以K12教育来说，全科教学的平台基本有2类，一类是互联网玩法的科技教育企业，如猿辅导和作业帮，一类是传统线下转型的企业，如新东方和好未来。随着
王慧文清华产品课（一）
weixin_43758551的博客
09-06 4132
链接 第一节课老王分享了他所认为的成功与失败的产品、成功的产品经理、如何看待这门课和产品经理这个职业，最后一个推荐书单最值得期待，请享用！ 如果大家感兴趣，多多支持，会尽快发出后续内容。 王慧文清华产品课Allen修订版（一） 前言 一、成功和失败的产品 一般来说在一个领域里一款产品的成功对应着无数产品的失败，根据老王个人的经验，成功和失败的比例大约是1:30，失败的原因多种多样，有些啥都没做对，有些作对了一部分，这里列举的失败案例主要讲做对了一部分的，准确说算是“成功的失败”。 iPhonevs. 诺
产品读书《用户力：需求驱动的产品、运营与商业模式》
女王の专属领地
12-20 6904
互联网产品是以人为本、需求驱动的产品，真正的服务于用户，关注用户。产品核心思想：互联网产品要MVP（最小化可行产品），永远没有完美的互联网产品，所以先上线再不断迭代。从“用户力”主题出发，以“用户需求驱动”为主线，对“互联网”、“用户需求”、“产品设计”、“网络运营”和“商业模式”5个部分进行系统性、结构化串联和构建，强调产品应该以用户需求驱动，产品不是满足用户需求，而是更优地...
软硬件产品/产品经理的异同，我适合什么？
人人都是产品经理
10-31 1万+
前段时间和海康威视的硬件产品总监们有些交流，聊到了如题的话题，整理一下。软硬件产品最根本的差异，是产品形态，比特与原子。问了硬件产品经理们，不含电路/芯片等的实体产品，比如一瓶水、一本书算硬件产品么？他们中的绝大多数都认为算。即，硬件产品可以没有软件，但软件必须依赖某种硬件，才能和用户交互。当然，我们日常接触的很多产品是软硬都有的，比如手机、汽车、摄像头。大家一起聊到了一些经常被提及的差异，但深入...
互联网产品设计思路参考
张晨光老师的播客
12-13 2376
互联网产品设计思路参考 产品开发流程 产品开发流程 产品研发产物 主要分为五个阶段：项目启动，需求阶段，产品设计，开发上线，版本迭代 立项 启动 评估 立项：确定要做一个什么产品 启动：确定项目相关人员，项目需求，产品原则，时间排期 评估：评估产品机会 需求阶段 需求收集 来源：老板提出，项目需求，产品优化，业务需求，用户需求，运营需求，增长需求，商业化需求等 方式：头脑风暴、用户调研、用户反馈、竞品分析和数据分析 头脑风暴 产品、运营、视觉、技术都可以参与。人数不要过多，超过5个效果反而不好。围绕着一个核
全新更新！《全国农产品成本收益资料汇编》（2022-1953）
热门推荐
2301_79696294的博客
08-31 6万+
来源于网络的资源版权归出版社或原作者所有，仅供学习，请勿用于商业。本资源部分自主研发，部分来源于网络。
产品经理的七个阶段
linapursue的博客
12-19 4180
一、第一阶段：需求细化与研发跟进 这个阶段基本上每天的工作都是写PRD、画原型、做DEMO。也就是基本处于一种被动分配任务的状态，接收的都是“二手需求”。一般而言自己思考产生的产品优化会比较少。也就是目前IT行业里面数百万的产品助理，甚至一些泛产品经理（从事类似工作，但不以产品经理为title的人）。基本来说，新人就是从这个阶段进行起步。按照天赋和努力的程度，有的可以半年时间跨过这个阶段，有
产品经理入门知识点
郭小姐的博客
12-04 2941
????，作为一个全方面发展的程序媛，第一步当然要先深入需求方啦。以下内容均为本人在编程之外学习的产品经理课程的归纳总结。属于精简重点版。 *产品经理定位 为产品和用户服务，忠诚于产品和用户， 有UI sense， 技术基础，运营前瞻性，逻辑性强，理解能力强 精于一点：（目前）只有产品经理能做的（需求评审PRD文档等） 能力： 1）用户分析（用户群，用户行为分析，产品卖点，需求痛点） 2）功能分析（产品调研，关键流程，产品结构，功能点） 3）流程原型（业务流程，产品原型，考核指标，需求文
产品生命周期
FengYanxuan的博客
05-24 2723
产品生命周期 一般可以分成四个阶段：引入期、成长期、成熟期和衰退期。 引入期 新产品投入市场，便进入了引入期。此时顾客对产品还不了解，除了少数追求新奇的顾客外，几乎没有人实际购买该产品。在此阶段产品生产批量小，制造成本高，广告费用大，产品销售价格偏高，销售量极为有限，企业通常不能获利。 成长期 当产品进入引入期，销售取得成功之后，便进入了成长期。这是需求增长阶段，需求量和销售额迅速上升，生产成本大幅度下降，利润迅速增长。 成熟期 经过成长期之后，随着购买产品的人数增多，市场需求趋于饱和，产品便进入了成熟期阶
ISO 14067-2018 ：温室气体 产品碳足迹 量化要求和指南（中文版）.pdf
12-23
ISO 14067-2018 ：温室气体 产品碳足迹 量化要求和指南（中文版）.pdf
产品设计(开发)文档模板
11-25
产品设计(开发)文档是软件或互联网产品开发过程中的重要组成部分，它清晰地定义了产品的功能、用户体验、技术规格和项目进度，为团队提供了一致的指导和参考。以下是对这个文档模板的详细解读： 首先，产品设计文档...
模拟篇|产品经理的面试题——产品问题1
2401_84391617的博客
04-24 2503
此刻还算是个互联网的初学者，我从应试角度，整合了全网有关的产品经理有关的面试题，下面就一起熟悉一下大佬们都从哪些方面入手考察我们吧！
智慧建造总体策划方案（76页）.pptx
11-02
智慧建造总体策划方案（76页）
基于 Python2.7 和 PyQT4 开发的 modbus 通信采集软件
11-02
基于 Python2.7 和 PyQT4 开发的 modbus 通信采集软件，已在 windows、deepin linux 和树莓派上测试！
LLC simulink仿真《slx模型文件》
11-02
LLC simulink仿真《slx模型文件》 LLC谐振转换器是一种高效的直流-直流(DC-DC)电源转换器，因其独特的谐振特性而得名。在电力电子领域，LLC仿真对于理解和优化这种转换器的性能至关重要。Simulink是MATLAB环境下的一个强大工具，用于建立和仿真复杂系统，包括电力电子系统。 标题“LLC simulink仿真”指的是使用Simulink进行LLC谐振转换器的建模和仿真。通过Simulink，工程师可以模拟LLC转换器在不同工作条件下的行为，如负载变化、输入电压变动以及控制策略的影响。 **LLC电路的基本原理：** LLC谐振转换器结合了升压（Boost）、降压（Buck）和串联谐振（Series Resonant）三种拓扑结构的特点。它由主开关、副开关、电感、电容和二极管组成。谐振电容和电感形成谐振回路，使得开关器件能在零电压或零电流条件下切换，从而降低开关损耗并提高效率。 **仿真过程：** 在Simulink中，首先需要建立LLC转换器的模型，包括各个元件的参数设定。这包括主开关和副开关的开关频率、谐振电容和电感的值、二极管的反向恢复特性等。然后，设
krb5-devel-1.15.1-55.el7_9.i686.rpm
11-02
Centos7 el7.x86_64 官方离线安装包，安装指令为 sudo rpm -ivh krb5-devel-1.15.1-55.el7_9.i686.rpm
基于Matlab实现Stanley算法项目源码（下载即用）高分项目
11-02
基于Matlab实现Stanley算法项目源码（下载即用）高分项目，本资源中的源码都是经过本地编译过可运行的，评审分达到98分，资源项目的难度比较适中，内容都是经过助教老师审定过的能够满足学习、毕业设计、期末大作业和课程设计使用需求，如果有需要的话可以放心下载使用。 基于Matlab实现Stanley算法项目源码（下载即用）高分项目基于Matlab实现Stanley算法项目源码（下载即用）高分项目基于Matlab实现Stanley算法项目源码（下载即用）高分项目基于Matlab实现Stanley算法项目源码（下载即用）高分项目基于Matlab实现Stanley算法项目源码（下载即用）高分项目基于Matlab实现Stanley算法项目源码（下载即用）高分项目基于Matlab实现Stanley算法项目源码（下载即用）高分项目基于Matlab实现Stanley算法项目源码（下载即用）高分项目基于Matlab实现Stanley算法项目源码（下载即用）高分项目基于Matlab实现Stanley算法项目源码（下载即用）高分项目基于Matlab实现Stanley算法项目源码（下载即用）高分项目基
ruby-2.0.0.648-39.el7_9.x86_64.rpm
最新发布
11-02
Centos7 el7.x86_64 官方离线安装包，安装指令为 sudo rpm -ivh ruby-2.0.0.648-39.el7_9.x86_64.rpm
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值