BLL层常需要使用的方法

最新推荐文章于 2023-04-07 17:37:25 发布
最新推荐文章于 2023-04-07 17:37:25 发布
阅读量1.5k 收藏 1
点赞数
文章标签： string null regex object html float
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/QiXing_Gan/article/details/5395016
版权

using System;
using System.Collections.Generic;
using System.Text;
using System.Security.Cryptography;
using System.Text.RegularExpressions;
using System.Web;
using System.Web.UI;
using Microsoft.VisualBasic;
using System.IO;
using System.Security.Permissions;
using System.Collections;
using System.Runtime.InteropServices;

namespace MyShop.BLL
{
    /// <summary>
    /// 工具类
    /// </summary>
    public class Utils
    {
        #region String字符串类
        /// <summary>
  /// 返回字符串真实长度, 1个汉字长度为2
  /// </summary>
  /// <returns></returns>
        public static int GetStringLength(string str)
        {
            return Encoding.Default.GetBytes(str).Length;
        }
        /// <summary>
        /// 过滤非法字符
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        public static string ReplaceBadChar(string str)
        {
            if (string.IsNullOrEmpty(str))
                return "";
            string strBadChar, tempChar;
            string[] arrBadChar;
            strBadChar = "@@,+,',--,%,^,&,?,(,),<,>,[,],{,},/,//,;,:,/",/"/",";
            arrBadChar = SplitString(strBadChar, ",");
            tempChar = str;
            for (int i = 0; i < arrBadChar.Length; i++)
            {
                if (arrBadChar[i].Length > 0)
                    tempChar = tempChar.Replace(arrBadChar[i], "");
            }
            return tempChar;
        }


        /// <summary>
        /// 检查是否含有非法字符
        /// </summary>
        /// <param name="str">要检查的字符串</param>
        /// <returns></returns>
        public static bool ChkBadChar(string str)
        {
            bool result = false;
            if (string.IsNullOrEmpty(str))
                return result;
            string strBadChar, tempChar;
            string[] arrBadChar;
            strBadChar = "@@,+,',--,%,^,&,?,(,),<,>,[,],{,},/,//,;,:,/",/"/"";
            arrBadChar = SplitString(strBadChar, ",");
            tempChar = str;
            for (int i = 0; i < arrBadChar.Length; i++)
            {
                if (tempChar.IndexOf(arrBadChar[i]) >= 0)
                    result = true;
            }
            return result;
        }


        /// <summary>
        /// 分割字符串
        /// </summary>
        public static string[] SplitString(string strContent, string strSplit)
        {
            int i = strContent.IndexOf(strSplit);
            if (strContent.IndexOf(strSplit) < 0)
            {
                string[] tmp = { strContent };
                return tmp;
            }
            //return Regex.Split(strContent, @strSplit.Replace(".", @"/."), RegexOptions.IgnoreCase);

            return Regex.Split(strContent, @strSplit.Replace(".", @"/."));
        }
        /// <summary>
        /// 检测是否有危险的可能用于链接的字符串
        /// </summary>
        /// <param name="str">要判断字符串</param>
        /// <returns>判断结果</returns>
        public static bool IsSafeUserInfoString(string str)
        {
            return !Regex.IsMatch(str, @"/^/s*$|^c://con//con$|[%,/*" + "/"" + @"/s/t/</>/&]|$guestexp/is");
        }

        /// <summary>
        /// string型转换为int型
        /// </summary>
        /// <param name="strValue">要转换的字符串</param>
        /// <returns>转换后的int类型结果.如果要转换的字符串是非数字,则返回-1.</returns>
        public static int StrToInt(object strValue)
        {
            int defValue = -1;
            if ((strValue == null) || (strValue.ToString() == string.Empty) || (strValue.ToString().Length > 10))
            {
                return defValue;
            }

            string val = strValue.ToString();
            string firstletter = val[0].ToString();

            if (val.Length == 10 && IsNumber(firstletter) && int.Parse(firstletter) > 1)
            {
                return defValue;
            }
            else if (val.Length == 10 && !IsNumber(firstletter))
            {
                return defValue;
            }


            int intValue = defValue;
            if (strValue != null)
            {
                bool IsInt = new Regex(@"^([-]|[0-9])[0-9]*$").IsMatch(strValue.ToString());
                if (IsInt)
                {
                    intValue = Convert.ToInt32(strValue);
                }
            }

            return intValue;
        }

        /// <summary>
        /// string型转换为int型
        /// </summary>
        /// <param name="strValue">要转换的字符串</param>
        /// <param name="defValue">缺省值</param>
        /// <returns>转换后的int类型结果</returns>
        public static int StrToInt(object strValue, int defValue)
        {
            if ((strValue == null) || (strValue.ToString() == string.Empty) || (strValue.ToString().Length > 10))
            {
                return defValue;
            }

            string val = strValue.ToString();
            string firstletter = val[0].ToString();

            if (val.Length == 10 && IsNumber(firstletter) && int.Parse(firstletter) > 1)
            {
                return defValue;
            }
            else if (val.Length == 10 && !IsNumber(firstletter))
            {
                return defValue;
            }


            int intValue = defValue;
            if (strValue != null)
            {
                bool IsInt = new Regex(@"^([-]|[0-9])[0-9]*$").IsMatch(strValue.ToString());
                if (IsInt)
                {
                    intValue = Convert.ToInt32(strValue);
                }
            }

            return intValue;
        }

        /// <summary>
        /// string型转换为float型
        /// </summary>
        /// <param name="strValue">要转换的字符串</param>
        /// <param name="defValue">缺省值</param>
        /// <returns>转换后的int类型结果</returns>
        public static float StrToFloat(object strValue, float defValue)
        {
            if ((strValue == null) || (strValue.ToString().Length > 10))
            {
                return defValue;
            }

            float intValue = defValue;
            if (strValue != null)
            {
                bool IsFloat = new Regex(@"^([-]|[0-9])[0-9]*(/./w*)?$").IsMatch(strValue.ToString());
                if (IsFloat)
                {
                    intValue = Convert.ToSingle(strValue);
                }
            }
            return intValue;
        }


        /// <summary>
        /// string型转换为时间型
        /// </summary>
        /// <param name="strValue">要转换的字符串</param>
        /// <param name="defValue">缺省值</param>
        /// <returns>转换后的时间类型结果</returns>
        public static DateTime StrToDateTime(object strValue,DateTime defValue)
        {
            if ((strValue == null) || (strValue.ToString().Length > 20))
            {
                return defValue;
            }

            DateTime intValue ;

            if (!DateTime.TryParse(strValue.ToString(), out intValue))
            {
                intValue =  defValue;
            }
            return intValue;
        }


        /// <summary>
        /// 判断给定的字符串(strNumber)是否是数值型
        /// </summary>
        /// <param name="strNumber">要确认的字符串</param>
        /// <returns>是则返加true 不是则返回 false</returns>
        public static bool IsNumber(string strNumber)
        {
            return new Regex(@"^([0-9])[0-9]*(/./w*)?$").IsMatch(strNumber);
        }


        /// <summary>
        /// 检测是否符合email格式
        /// </summary>
        /// <param name="strEmail">要判断的email字符串</param>
        /// <returns>判断结果</returns>
        public static bool IsValidEmail(string strEmail)
        {
            return Regex.IsMatch(strEmail, @"^([/w-/.]+)@((/[[0-9]{1,3}/.[0-9]{1,3}/.[0-9]{1,3}/.)|(([/w-]+/.)+))([a-zA-Z]{2,4}|[0-9]{1,3})(/]?)$");
        }


        /// <summary>
        /// 检测是否符合url格式,前面必需含有http://
        /// </summary>
        /// <param name="url"></param>
        /// <returns></returns>
        public static bool IsURL(string url)
        {
            return Regex.IsMatch(url,@"^http(s)?://([/w-]+/.)+[/w-]+(/[/w- ./?%&=]*)?$");
        }

        /// <summary>
        /// 检测是否符合电话格式
        /// </summary>
        /// <param name="phoneNumber"></param>
        /// <returns></returns>
        public static bool IsPhoneNumber(string phoneNumber)
        {
            return Regex.IsMatch(phoneNumber,@"^(/(/d{3}/)|/d{3}-)?/d{7,8}$");
        }

 

        /// <summary>
        /// 检测是否符合时间格式
        /// </summary>
        /// <returns></returns>
        public static bool IsTime(string timeval)
        {
            return Regex.IsMatch(timeval, @"20/d{2}/-[0-1]{1,2}/-[0-3]?[0-9]?(/s*((([0-1]?[0-9])|(2[0-3])):([0-5]?[0-9])(:[0-5]?[0-9])?))?");
        }

 

        /// <summary>
        /// 检测是否符合身份证号码格式
        /// </summary>
        /// <param name="num"></param>
        /// <returns></returns>
        public static bool IsIdentityNumber(string num)
        {
            return Regex.IsMatch(num, @"^/d{17}[/d|X]|/d{15}$");
        }

        /// <summary>
        /// 检测是否符合邮编格式
        /// </summary>
        /// <param name="postCode"></param>
        /// <returns></returns>
        public static bool IsPostCode(string postCode)
        {
            return Regex.IsMatch(postCode, @"^/d{6}$");
        }


        /// <summary>
        /// MD5函数
        /// </summary>
        /// <param name="str">原始字符串</param>
        /// <returns>MD5结果</returns>
        public static string MD5(string str)
        {
            byte[] b = Encoding.Default.GetBytes(str);
            b = new MD5CryptoServiceProvider().ComputeHash(b);
            string ret = "";
            for (int i = 0; i < b.Length; i++)
                ret += b[i].ToString("x").PadLeft(2, '0');
            return ret;
        }

 

        /// <summary>
        /// 转换为简体中文
        /// </summary>
        public static string ToSChinese(string str)
        {
            return Strings.StrConv(str, VbStrConv.SimplifiedChinese, 0);
        }

        /// <summary>
        /// 转换为繁体中文
        /// </summary>
        public static string ToTChinese(string str)
        {
            return Strings.StrConv(str, VbStrConv.TraditionalChinese, 0);
        }

        /// <summary>
        /// 自定义的替换字符串函数
        /// </summary>
        public static string ReplaceString(string SourceString, string SearchString, string ReplaceString, bool IsCaseInsensetive)
        {
            return Regex.Replace(SourceString, Regex.Escape(SearchString), ReplaceString, IsCaseInsensetive ? RegexOptions.IgnoreCase : RegexOptions.None);
        }

        /// <summary>
        /// 检查一个数组中所有的元素是否有包含于指定字符串的元素
        /// </summary>
        /// <param name="arr">存储数据数据的字串</param>
        /// <param name="toFind">要查找的字符串</param>
        /// <param name="separator">数组的分隔符</param>
        /// <returns></returns>
        public static bool FoundStringInArr(string arr, string toFind, char separator)
        {
            if (arr.IndexOf(separator) >= 0)
            {
                string[] arrTemp = arr.Split('|');
                for (int i = 0; i < arrTemp.Length; i++)
                {
                    if ( ( toFind.ToLower().IndexOf( arrTemp[i].ToLower() ) >= 0) && (arrTemp[i].ToLower() != ""))
                        return true;
                }

            }
            else
            {
                if ( ( toFind.ToLower().IndexOf(arr.ToLower()) ) >= 0 && (arr.ToLower()!=""))
                    return true;
            }
            return false;
        }


        #endregion

        #region Sql类

        /// <summary>
        /// 检测是否有Sql危险字符
        /// </summary>
        /// <param name="str">要判断字符串</param>
        /// <returns>判断结果</returns>
        public static bool IsSafeSqlString(string str)
        {

            return !Regex.IsMatch(str, @"[-|;|,|//|/(|/)|/[|/]|/}|/{|%|@|/*|!|/']");
        }

        /// <summary>
        /// 改正sql语句中的转义字符
        /// </summary>
        public static string mashSQL(string str)
        {
            string str2;

            if (str == null)
            {
                str2 = "";
            }
            else
            {
                str = str.Replace("/'", "'");
                str2 = str;
            }
            return str2;
        }

        /// <summary>
        /// 替换sql语句中的有问题符号
        /// </summary>
        public static string ReplaceBadSQL(string str)
        {
            string str2;

            if (str == null)
            {
                str2 = "";
            }
            else
            {
                str = str.Replace("'", "''");
                str2 = str;
            }
            return str2;
        }

 

        #endregion

        #region Html类

        /// <summary>
        /// 返回 HTML 字符串的编码结果
        /// </summary>
        /// <param name="str">字符串</param>
        /// <returns>编码结果</returns>
        public static string HtmlEncode(string str)
        {
           // str = str.Replace("'", "''");
            return HttpUtility.HtmlEncode(str);

        }

        /// <summary>
        /// 返回 HTML 字符串的解码结果
        /// </summary>
        /// <param name="str">字符串</param>
        /// <returns>解码结果</returns>
        public static string HtmlDecode(string str)
        {
            //str = str.Replace("''", "'");
            return HttpUtility.HtmlDecode(str);
        }

        /// <summary>
        /// 替换html字符
        /// </summary>
        public static string EncodeHtml(string strHtml)
        {
            if (strHtml != "")
            {
                strHtml = strHtml.Replace(",", "&def");
                strHtml = strHtml.Replace("'", "&dot");
                strHtml = strHtml.Replace(";", "&dec");
                return strHtml;
            }
            return "";
        }

        /// <summary>
        /// 替换回车换行符为html换行符
        /// </summary>
        public static string StrFormat(string str)
        {
            string str2;

            if (str == null)
            {
                str2 = "";
            }
            else
            {
                str = str.Replace("/r/n", "<br />");
                str = str.Replace("/n", "<br />");
                str2 = str;
            }
            return str2;
        }
        #endregion

        #region DateTime类


        /// <summary>
        /// 返回标准日期格式string
        /// </summary>
        public static string GetDate()
        {
            return DateTime.Now.ToString("yyyy-MM-dd");
        }

        /// <summary>
        /// 返回指定日期格式
        /// </summary>
        public static string GetDate(string datetimestr, string replacestr)
        {
            if (datetimestr == null)
            {
                return replacestr;
            }

            if (datetimestr.Equals(""))
            {
                return replacestr;
            }

            try
            {
                datetimestr = Convert.ToDateTime(datetimestr).ToString("yyyy-MM-dd").Replace("1900-01-01", replacestr);
            }
            catch
            {
                return replacestr;
            }
            return datetimestr;

        }


        /// <summary>
        /// 返回标准时间格式string
        /// </summary>
        public static string GetTime()
        {
            return DateTime.Now.ToString("HH:mm:ss");
        }

        /// <summary>
        /// 返回标准时间格式string
        /// </summary>
        public static string GetDateTime()
        {
            return DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
        }

        /// <summary>
        /// 返回相对于当前时间的相对天数
        /// </summary>
        public static string GetDateTime(int relativeday)
        {
            return DateTime.Now.AddDays(relativeday).ToString("yyyy-MM-dd HH:mm:ss");
        }

        /// <summary>
        /// 返回标准时间格式string
        /// </summary>
        public static string GetDateTimeF()
        {
            return DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss:fffffff");
        }

        /// <summary>
        /// 返回标准时间
        /// </sumary>
        public static string GetStandardDateTime(string fDateTime, string formatStr)
        {
            DateTime s = Convert.ToDateTime(fDateTime);
            return s.ToString(formatStr);
        }

        /// <summary>
        /// 返回标准时间 yyyy-MM-dd HH:mm:ss
        /// </sumary>
        public static string GetStandardDateTime(string fDateTime)
        {
            return GetStandardDateTime(fDateTime, "yyyy-MM-dd HH:mm:ss");
        }
        /// <summary>
        /// 返回相差的秒数
        /// </summary>
        /// <param name="Time"></param>
        /// <param name="Sec"></param>
        /// <returns></returns>
        public static int StrDateDiffSeconds(string Time, int Sec)
        {
            TimeSpan ts = DateTime.Now - DateTime.Parse(Time).AddSeconds(Sec);
            if (ts.TotalSeconds > int.MaxValue)
            {
                return int.MaxValue;
            }
            else if (ts.TotalSeconds < int.MinValue)
            {
                return int.MinValue;
            }
            return (int)ts.TotalSeconds;
        }

        /// <summary>
        /// 返回相差的分钟数
        /// </summary>
        /// <param name="time"></param>
        /// <param name="minutes"></param>
        /// <returns></returns>
        public static int StrDateDiffMinutes(string time, int minutes)
        {
            if (time == "" || time == null)
                return 1;
            TimeSpan ts = DateTime.Now - DateTime.Parse(time).AddMinutes(minutes);
            if (ts.TotalMinutes > int.MaxValue)
            {
                return int.MaxValue;
            }
            else if (ts.TotalMinutes < int.MinValue)
            {
                return int.MinValue;
            }
            return (int)ts.TotalMinutes;
        }

        /// <summary>
        /// 返回相差的小时数
        /// </summary>
        /// <param name="time"></param>
        /// <param name="hours"></param>
        /// <returns></returns>
        public static int StrDateDiffHours(string time, int hours)
        {
            if (time == "" || time == null)
                return 1;
            TimeSpan ts = DateTime.Now - DateTime.Parse(time).AddHours(hours);
            if (ts.TotalHours > int.MaxValue)
            {
                return int.MaxValue;
            }
            else if (ts.TotalHours < int.MinValue)
            {
                return int.MinValue;
            }
            return (int)ts.TotalHours;
        }

        #endregion

        #region file类

        /// <summary>
        /// 得到网站的真实路径
        /// </summary>
        /// <returns></returns>
        public static string GetTrueWebSitePath()
        {
            string path = HttpContext.Current.Request.Path;
            if (path.LastIndexOf("/") != path.IndexOf("/"))
            {
                path = path.Substring(path.IndexOf("/"), path.LastIndexOf("/") + 1);
            }
            else
            {
                path = "/";
            }
            return path;

        }

        /// <summary>
        /// 文件是否存在
        /// </summary>
        /// <param name="filePath">相对路径</param>
        /// <returns></returns>
        public static bool FileExists(string filePath)
        {
            if (string.IsNullOrEmpty(filePath))
                return false;
            filePath = HttpContext.Current.Server.MapPath(filePath);
            DirectoryInfo dirInfo = new DirectoryInfo(filePath);
            if (dirInfo.Exists)
                return true;
            return false;
        }

        /// <summary>
        /// 创建目录
        /// </summary>
        /// <param name="filePath">相对路径</param>
        /// <returns>是否成功</returns>
        public static  bool CreateDirectory(string filePath)
        {
            if (string.IsNullOrEmpty(filePath))
                return false;
            filePath = HttpContext.Current.Server.MapPath(filePath);
            DirectoryInfo dirInfo = new DirectoryInfo(filePath);
            if (dirInfo.Exists)
                return true;
            try
            {
                Directory.CreateDirectory(filePath);
                return true;
            }
            catch
            {
                return false;
            }
        }

        #endregion

        #region Number类

        /// <summary>
        /// 将long型数值转换为Int32类型
        /// </summary>
        /// <param name="objNum"></param>
        /// <returns></returns>
        public static int SafeInt32(object objNum)
        {
            if (objNum == null)
            {
                return 0;
            }
            string strNum = objNum.ToString();
            if (IsNumber(strNum))
            {

                if (strNum.ToString().Length > 9)
                {
                    return int.MaxValue;
                }
                return Int32.Parse(strNum);
            }
            else
            {
                return 0;
            }
        }


        #endregion
    }
}

isme2013
关注
C#代码模板生成器;Model层;DAL层;BLL层代码自动生成
02-25
例如，可以调整生成的Model类是否包含属性的Get、Set方法，BLL层是否包含事务处理，或者DAL层是否使用特定的ORM框架。这些自定义模板让代码生成器更加灵活，以满足各种复杂场景。 总的来说，C#代码模板生成器对于...
BLL层：方法单一VS单一方法
赵丹丹 廊坊师范学院信息技术提高班 七期
04-11 1780
      BLL层即业务逻辑层，是处理业务逻辑判断的，可是这个判断是放到一个方法里还是分成多个方法呢？      题目说的“方法单一”即在BLL层里存放多个方法（有主方法和辅助方法，主方法调用辅助方法），是每个方法都有单一的功能；而“单一方法”即在BLL层中只存在一个主方法。      注：“主方法”：窗体需要调用BLL层的方法；“辅助方法”：例如一些判断，需要被主方法调用。      有些人可能会认为业务逻辑层不就是处理那些复杂的判断吗？那我写的越复杂岂不是越好？      下面我们就以充值卡为例，通过
三层
weixin_33841722的博客
09-27 96
三层 三层只是一个比较好的软件架构，不是非用三层不可。 界面层UI（user interface）； 数据访问层DAL（Data Access Layer）； 业务逻辑层BLL（business logic layer ）。实体类就是Model；对数据进行操作的代码写在DAL中，一般就是SQL语句，DAL只有对数据的操作，没有“如果金额大于20则不能删除”这样的逻辑；BLL调用DAL中的代...
ASP.NET三层架构——BLL层(业务逻辑层)
YHBoy11的博客
06-23 2494
今天，我们来学习一下BLL层的框架搭建： 在创建BLL层之后，我们要搭建BLL层中的Manage类，具体样式参照下图： 注意：我们要遵循一个原则：要根据DAL层中的Service类来创建BLL层的Manage类，也就是一个Service类对应一个Manage类。 在Manage类中，首先，我们需要引用几个命名空间： using System.Data; using DAL; using Model; 接着，我们要将Service类中的（增删改查）方法给复制粘贴到对应的Manage类中：
C#_三层（BLL DAL Model）架构详解
KevinJee_
04-23 3万+
C#_三层架构详解 三层架构： 表现层（UI）、业务逻辑层（BLL）、数据访问层（DAL）再加上实体类库（Model） 表现层（UI）：一般都是窗体的设计或者网页的设计，是可以一眼就可以看到的界面。 业务逻辑层（BLL）：对传送数据进行逻辑判断分折，并进行传送正确的值。 数据访问层（DAL）：主要是存放对数据类的访问，即对数据库的添加、删除、修改、更新等基本操作。 实体类库（Model）：主要存放...
三层架构（UI、BLL、DAL）
xiaoyu_alive的博客
03-21 9745
讲述了三层架构：表示层 / 表现层 / 界面层（UI）、业务逻辑层（BLL）、数据访问层（DAL）
三层架构 c# BLL DAL MODEL
12-27
BLL层处理来自UI层的请求，并向DAL层发送数据访问请求。这一层的职责是处理业务规则，如计算、验证等，确保数据的完整性和一致性。例如，在一个电商系统中，BLL可能包含商品库存管理、订单处理和用户权限检查等功能...
asp.net 三层架构实例 BLL DAL Model
11-11
在`gridview3layers`中，BLL可能会有一些方法，这些方法被UI层调用，用于填充`GridView`或者处理用户提交的数据。BLL会调用DAL中的方法来获取或更新数据，同时也会对数据进行验证和处理。 3. 表示层（UI层）：ASP...
ASP.NET 三层框架搭建 BLL+IDAL+DAL+DB+MODEL
11-17
在ASP.NET中，三层架构的应用往往还包括对MODEL的进一步封装，如使用Entity Framework或NHibernate这样的ORM（对象关系映射）工具，将数据库表自动映射为.NET类，简化了数据操作。 总结起来，ASP.NET 三层架构提供...
通用Bll 通用Dal
02-20
- `BaseBll`和`BaseDal`类：这是BLL和DAL层的基类，提供了通用的方法和属性，如数据访问的接口、事务处理等。 - `ReflectionHelper`类：封装了反射相关的操作，方便其他类使用。 - `AutoMapping`：可能包含了一个...
C#中三层架构UI、BLL、DAL、Model实际操作
guocs415的博客
09-08 3175
到这里三层就完事了，主要就是解耦，包括最近火的ABP框架，七层一类的，说白了就是能更好的实现新的逻辑。三个实体，对应了三个DAL，（也可以写在一起），可以新建立一个DAL，去调用，UI再去调用这一个。数据访问层（DAL）：主要是存放对数据类的访问，即对数据库的添加、删除、修改、更新等基本操作。业务逻辑层（BLL）：对传送数据进行逻辑判断分折，并进行传送正确的值。BLL层调用DAL层、Model层、Common层。UI层调用BLL层、Model层、Common层。DAL层调用Model层，Common层。
三层架构-BLL层
Rianan的博客
06-25 1864
BLL层(调用DAL增删改查方法) 创建DAL层使用类库 在DAL层创建类对应Model层(ps:起名方式 Model类名后加Service) 在DAL层添加引用: DAL System.Data 使用Model对象时添加Model 创建类后检查是否具有public属性 没有要手动加上 不然无法调用 使用复制DAL的增删改查方法 然后修改return 返回的方法使用DAL /// <summary> /// 查询 /// </summ...
三层架构之业务逻辑层（BLL）
weixin_48319014的博客
06-25 4834
一、BLL:针对具体问题的操作，也可以说是对数据层的操作，对数据业务逻辑处理。 1、模板: windows->类库 2、引用: Model、DAL 3、原则:一个Service对应一个Manage类 4、实现:复制DAL层、粘贴,到BLL层，改为调用 DAL层 BLL层 把DAL层里的内容删除，然后return调用DAL层所编写的方法 明天将会给大家讲述三层架构中最重要的UL层，可能内容会有点多，会分开讲解 ...
C#的三层架构：UI、BLL、DAL
最新发布
weixin_40362806的博客
04-07 1662
C#的三层架构
步步为营 .NET三层架构解析 六、BLL的设计
weixin_33901843的博客
01-08 222
      BLL层，又叫业务逻辑层，顾名思义，就是放置业务逻辑的地方.      业务逻辑层在体系架构中的位置很关键，它处于数据访问层与表示层中间，起到了数据交换中承上启下的作用。由于层是一种弱耦合结构，层与层之间的依赖是向下的，底层对于上层而言是“无知”的，改变上层的设计对于其调用的底层而言没有任何影响。如果在分层设计时，遵循了面向接口设计的思想，那么这种向下的依赖也应该是一种弱依赖关系。因...
C#中三层架构UI、BLL、DAL、Model详解
热门推荐
liutong123987的专栏
01-30 6万+
三层架构分为：表现层（UI）、业务逻辑层（BLL）、数据访问层（DAL）再加上实体类库（Model） 转载请注明出自朱朱家园https://blog.csdn.net/zhgl7688 1、实体类库（Model），主要存放数据库中的表字段。 操作： （1）先建立实体类库Model，打开项目，在解决方案中右键--》添加--》新建项目--》选中类库--》改名Model--》确定 （2）选中M
ASP.NET三层架构BLL层
Heroine11111的博客
06-28 789
BLL层(业务逻辑层)：主要是针对具体的问题的操作，也可以理解成对数据层的操作，对数据业务逻辑处理。负责关键业务的处理和数据的传递。复杂的逻辑判断和涉及到数据库的数据验证都需要在此做出处理。根据传入的值返回用户想得到的值，或者处理相关的逻辑。 1. 模板: windows->类库 2.引用: Model、DAL 3. 原则:一个Service对应一个Manage类 4.实现:复制、粘贴，改为调用 ...
理解.NET三层架构：UI、BLL与DAL
当表示层接收到用户请求后，会调用BLL中的相应方法，这些方法会根据业务需求处理数据，执行计算，进行逻辑判断，并可能需要调用数据访问层获取或更新数据。BLL是与具体技术无关的，因此可以独立于表示层和数据访问层...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值