清风的blog - 程序语言http://blog.careff.com/优然探索 - RainbowSoft Studio Z-Blog 2.2 Prism Build 140101zh-CNCopyright (C) 2008-2024 careff.com Inc.,All Rights Reserved. 雅虎统计 Tue, 09 Jun 2026 11:28:35 +0800windows2008 删除文件a@b.com (admin)http://blog.careff.com/post/377.htmlThu, 12 Sep 2013 19:13:51 +0800http://blog.careff.com/post/377.html@echo off

rem write to log

set filename=deletefile.log

echo -------------------Delete Expired Log Files------------------------- >>%filename%

echo Start >>%filename%

echo (%date% %time%) >>%filename%

echo Delete the expired log files in D:\Users\Administrator\Desktop\2\1, Please wait... >>%filename%

forfiles.exe /p "D:\Users\Administrator\Desktop\SchoolDB" /s /m *.* /d -2 /c "cmd /c del @path"

echo End >>%filename%

echo (%date% %time%) >>%filename%

 

]]>程序语言http://blog.careff.com/post/377.html#commenthttp://blog.careff.com/feed.asp?cmt=377c# md5函数a@b.com (admin)http://blog.careff.com/post/355.htmlWed, 13 Mar 2013 10:03:21 +0800http://blog.careff.com/post/355.html  public string Encrypt(string str)

        {
            string cl = str;
            string pwd = "";
            MD5 md5 = MD5.Create();//实例化一个md5对像
            // 加密后是一个字节类型的数组，这里要注意编码UTF8/Unicode等的选择　
            byte[] s = md5.ComputeHash(Encoding.UTF8.GetBytes(cl));
            // 通过使用循环，将字节类型的数组转换为字符串，此字符串是常规字符格式化所得
            for (int i = 0; i < s.Length; i++)
            {
                // 将得到的字符串使用十六进制类型格式。格式后的字符是小写的字母，如果使用大写（X）则格式后的字符是大写字符 
 
                pwd = pwd + s[i].ToString("X");
 
            }
            return pwd;
        }
]]>程序语言http://blog.careff.com/post/355.html#commenthttp://blog.careff.com/feed.asp?cmt=355SQL2008删除日志a@b.com (admin)http://blog.careff.com/post/344.htmlTue, 20 Mar 2012 08:32:20 +0800http://blog.careff.com/post/344.html 

USE [master]
GO
ALTER DATABASE LcExamNews SET RECOVERY SIMPLE WITH NO_WAIT
GO
ALTER DATABASE LcExamNews SET RECOVERY SIMPLE --简单模式
GO
USE LcExamNews
GO
DBCC SHRINKFILE (N'LcExamNews_Log' , 11, TRUNCATEONLY)
GO
USE [master]
GO
ALTER DATABASE LcExamNews SET RECOVERY FULL WITH NO_WAIT
GO
ALTER DATABASE LcExamNews SET RECOVERY FULL --还原为完全模式
GO
]]>程序语言http://blog.careff.com/post/344.html#commenthttp://blog.careff.com/feed.asp?cmt=344更新Web.configa@b.com (admin)http://blog.careff.com/post/223.htmlSun, 29 Nov 2009 23:18:10 +0800http://blog.careff.com/post/223.htmlprivate void UpdateConfig(string KeyName, string Xvalue)
        {
            XmlDocument doc = new XmlDocument();
            string sPath = Server.MapPath("web.config");
            doc.Load(sPath);
            XmlNode node = doc.SelectSingleNode(@"//add[@key='" + KeyName + "']");
            XmlElement ele = (XmlElement)node;
            ele.SetAttribute("value", Xvalue);
            doc.Save(sPath);
        }

]]>程序语言http://blog.careff.com/post/223.html#commenthttp://blog.careff.com/feed.asp?cmt=223C#.net 实现MD5加密a@b.com (admin)http://blog.careff.com/post/64.htmlThu, 11 Sep 2008 10:35:13 +0800http://blog.careff.com/post/64.htmlusing System;
using System.Text;

namespace Encrypter
{
 /// <summary>
 /// Summary description for MD5.
 /// </summary>
 public class MD5
 {
  const int BITS_TO_A_BYTE = 8;
  const int BYTES_TO_A_WORD = 4;
  const int BITS_TO_A_WORD = 32;
  private static long[] m_lOnBits = new long[30 + 1];
  private static long[] m_l2Power = new long[30 + 1];

  private static long LShift(long lValue, long iShiftBits)
  {
   long LShift = 0;
   if (iShiftBits == 0)
   {
    LShift = lValue;
    return LShift;
   }
   else
   {
    if( iShiftBits == 31)
    {
     if (Convert.ToBoolean(lValue & 1))
     {
      LShift = 0x80000000;
     }
     else
     {
      LShift = 0;
     }
     return LShift;
    }
    else
    {
     if( iShiftBits < 0 || iShiftBits > 31)
     {
      // Err.Raise 6;
     }
    }
   }

   if (Convert.ToBoolean((lValue & m_l2Power[31 - iShiftBits])))
   {
    LShift = ((lValue & m_lOnBits[31 - (iShiftBits + 1)]) * m_l2Power[iShiftBits]) | 0x80000000;
   }
   else
   {
    LShift = ((lValue & m_lOnBits[31 - iShiftBits]) * m_l2Power[iShiftBits]);
   }

   return LShift;
  }

  private static long RShift(long lValue, long iShiftBits)
  {
   long RShift = 0;
   if (iShiftBits == 0)
   {
    RShift = lValue;
    return RShift;
   }
   else
   {
    if( iShiftBits == 31)
    {
     if (Convert.ToBoolean(lValue & 0x80000000))
     {
      RShift = 1;
     }
     else
     {
      RShift = 0;
     }
     return RShift;
    }
    else
    {
     if( iShiftBits < 0 || iShiftBits > 31)
     {
      // Err.Raise 6;
     }
    }
   }

   RShift = (lValue & 0x7FFFFFFE) / m_l2Power[iShiftBits];

   if (Convert.ToBoolean((lValue & 0x80000000)))
   {
    RShift = (RShift | (0x40000000 / m_l2Power[iShiftBits - 1]));
   }

   return RShift;
  }

  private static long RotateLeft(long lValue, long iShiftBits)
  {
   long RotateLeft = 0;
   RotateLeft = LShift(lValue, iShiftBits) | RShift(lValue, (32 - iShiftBits));
   return RotateLeft;
  }

  private static long AddUnsigned(long lX, long lY)
  {
   long AddUnsigned = 0;
   long lX4 = 0;
   long lY4 = 0;
   long lX8 = 0;
   long lY8 = 0;
   long lResult = 0;
   lX8 = lX & 0x80000000;
   lY8 = lY & 0x80000000;
   lX4 = lX & 0x40000000;
   lY4 = lY & 0x40000000;

   lResult = (lX & 0x3FFFFFFF) + (lY & 0x3FFFFFFF);
   if (Convert.ToBoolean(lX4 & lY4))
   {
    lResult = lResult ^ 0x80000000 ^ lX8 ^ lY8;
   }
   else if( Convert.ToBoolean(lX4 | lY4))
   {
    if (Convert.ToBoolean(lResult & 0x40000000))
    {
     lResult = lResult ^ 0xC0000000 ^ lX8 ^ lY8;
    }
    else
    {
     lResult = lResult ^ 0x40000000 ^ lX8 ^ lY8;
    }
   }
   else
   {
    lResult = lResult ^ lX8 ^ lY8;
   }
   AddUnsigned = lResult;
   return AddUnsigned;
  }

  private static long md5_F(long x, long y, long z)
  {
   long md5_F = 0;
   md5_F = (x & y) | (( ~x) & z);
   return md5_F;
  }

  private static long md5_G(long x, long y, long z)
  {
   long md5_G = 0;
   md5_G = (x & z) | (y & ( ~z));
   return md5_G;
  }

  private static long md5_H(long x, long y, long z)
  {
   long md5_H = 0;
   md5_H = (x ^ y ^ z);
   return md5_H;
  }

  private static long md5_I(long x, long y, long z)
  {
   long md5_I = 0;
   md5_I = (y ^ (x | (~z)));
   return md5_I;
  }

  private static void md5_FF(ref long a, long b, long c, long d, long x, long s, long ac)
  {
   a = AddUnsigned(a, AddUnsigned(AddUnsigned(md5_F(b, c, d), x), ac));
   a = RotateLeft(a, s);
   a = AddUnsigned(a, b);
  }

  private static void md5_GG(ref long a, long b, long c, long d, long x, long s, long ac)
  {
   a = AddUnsigned(a, AddUnsigned(AddUnsigned(md5_G(b, c, d), x), ac));
   a = RotateLeft(a, s);
   a = AddUnsigned(a, b);
  }

  private static void md5_HH(ref long a, long b, long c, long d, long x, long s, long ac)
  {
   a = AddUnsigned(a, AddUnsigned(AddUnsigned(md5_H(b, c, d), x), ac));
   a = RotateLeft(a, s);
   a = AddUnsigned(a, b);
  }

  private static void md5_II(ref long a, long b, long c, long d, long x, long s, long ac)
  {
   a = AddUnsigned(a, AddUnsigned(AddUnsigned(md5_I(b, c, d), x), ac));
   a = RotateLeft(a, s);
   a = AddUnsigned(a, b);
  }

  private static long[] ConvertToWordArray(string sMessage)
  {
   long[] ConvertToWordArray = null;
   int lMessageLength = 0;
   int lNumberOfWords = 0;
   long[] lWordArray = null;
   int lBytePosition = 0;
   int lByteCount = 0;
   int lWordCount = 0;

   const int MODULUS_BITS = 512;
   const int CONGRUENT_BITS = 448;

   lMessageLength = sMessage.Length;
   lNumberOfWords = (((lMessageLength + ((MODULUS_BITS - CONGRUENT_BITS) / BITS_TO_A_BYTE)) / (MODULUS_BITS / BITS_TO_A_BYTE)) + 1) * (MODULUS_BITS / BITS_TO_A_WORD);
   lWordArray = new long[lNumberOfWords];

   lBytePosition = 0;
   lByteCount = 0;

   while(lByteCount < lMessageLength)
   {
    lWordCount = lByteCount / BYTES_TO_A_WORD;
    lBytePosition = (lByteCount % BYTES_TO_A_WORD) * BITS_TO_A_BYTE;
    lWordArray[lWordCount] = lWordArray[lWordCount] | LShift(Convert.ToByte(sMessage.Substring(lByteCount, 1).ToCharArray()[0]), lBytePosition);
    lByteCount = lByteCount + 1;
   }

   lWordCount = lByteCount / BYTES_TO_A_WORD;
   lBytePosition = (lByteCount % BYTES_TO_A_WORD) * BITS_TO_A_BYTE;
   lWordArray[lWordCount] = lWordArray[lWordCount] | LShift(0x80, lBytePosition);
   lWordArray[lNumberOfWords - 2] = LShift(lMessageLength, 3);
   lWordArray[lNumberOfWords - 1] = RShift(lMessageLength, 29);
   ConvertToWordArray = lWordArray;

   return ConvertToWordArray;
  }

  private static string WordToHex(long lValue)
  {
   string WordToHex = "";
   long lByte = 0;
   int lCount = 0;
   for(lCount = 0; lCount <= 3; lCount++)
   {
    lByte = RShift(lValue, lCount * BITS_TO_A_BYTE) & m_lOnBits[BITS_TO_A_BYTE - 1];
    WordToHex = WordToHex + (("0" + ToHex(lByte)).Substring(("0" + ToHex(lByte)).Length - 2));
   }
   return WordToHex;
  }

  private static string ToHex(long dec)
  {
   string strhex = "";
   while(dec > 0)
   {
    strhex = tohex(dec % 16) + strhex;
    dec = dec / 16;
   }
   return strhex;
  }
 
  private static string tohex(long hex)
  {
   string strhex = "";
   switch(hex)
   {
    case 10: strhex = "a"; break;
    case 11: strhex = "b"; break;
    case 12: strhex = "c"; break;
    case 13: strhex = "d"; break;
    case 14: strhex = "e"; break;
    case 15: strhex = "f"; break;
    default : strhex = hex.ToString(); break;
   }
   return strhex;
  }


  public static string Encrypt(string sMessage, int stype)
  {
   string MD5 = "";
  
   for(int i=0; i<=30; i++)
   {
    m_lOnBits[i] = Convert.ToInt64(Math.Pow(2, i+1) -1);
    m_l2Power[i] = Convert.ToInt64(Math.Pow(2, i));
   }

   long[] x = null;
   int k = 0;
   long AA = 0;
   long BB = 0;
   long CC = 0;
   long DD = 0;
   long a = 0;
   long b = 0;
   long c = 0;
   long d = 0;

   const int S11 = 7;
   const int S12 = 12;
   const int S13 = 17;
   const int S14 = 22;
   const int S21 = 5;
   const int S22 = 9;
   const int S23 = 14;
   const int S24 = 20;
   const int S31 = 4;
   const int S32 = 11;
   const int S33 = 16;
   const int S34 = 23;
   const int S41 = 6;
   const int S42 = 10;
   const int S43 = 15;
   const int S44 = 21;

   x = ConvertToWordArray(sMessage);

   a = 0x67452301;
   b = 0xEFCDAB89;
   c = 0x98BADCFE;
   d = 0x10325476;

   for(k = 0; k < x.Length; k += 16)
   {
    AA = a;
    BB = b;
    CC = c;
    DD = d;

    md5_FF(ref a, b, c, d, x[k + 0], S11, 0xD76AA478);
    md5_FF(ref d, a, b, c, x[k + 1], S12, 0xE8C7B756);
    md5_FF(ref c, d, a, b, x[k + 2], S13, 0x242070DB);
    md5_FF(ref b, c, d, a, x[k + 3], S14, 0xC1BDCEEE);
    md5_FF(ref a, b, c, d, x[k + 4], S11, 0xF57C0FAF);
    md5_FF(ref d, a, b, c, x[k + 5], S12, 0x4787C62A);
    md5_FF(ref c, d, a, b, x[k + 6], S13, 0xA8304613);
    md5_FF(ref b, c, d, a, x[k + 7], S14, 0xFD469501);
    md5_FF(ref a, b, c, d, x[k + 8], S11, 0x698098D8);
    md5_FF(ref d, a, b, c, x[k + 9], S12, 0x8B44F7AF);
    md5_FF(ref c, d, a, b, x[k + 10], S13, 0xFFFF5BB1);
    md5_FF(ref b, c, d, a, x[k + 11], S14, 0x895CD7BE);
    md5_FF(ref a, b, c, d, x[k + 12], S11, 0x6B901122);
    md5_FF(ref d, a, b, c, x[k + 13], S12, 0xFD987193);
    md5_FF(ref c, d, a, b, x[k + 14], S13, 0xA679438E);
    md5_FF(ref b, c, d, a, x[k + 15], S14, 0x49B40821);
    md5_GG(ref a, b, c, d, x[k + 1], S21, 0xF61E2562);
    md5_GG(ref d, a, b, c, x[k + 6], S22, 0xC040B340);
    md5_GG(ref c, d, a, b, x[k + 11], S23, 0x265E5A51);
    md5_GG(ref b, c, d, a, x[k + 0], S24, 0xE9B6C7AA);
    md5_GG(ref a, b, c, d, x[k + 5], S21, 0xD62F105D);
    md5_GG(ref d, a, b, c, x[k + 10], S22, 0x2441453);
    md5_GG(ref c, d, a, b, x[k + 15], S23, 0xD8A1E681);
    md5_GG(ref b, c, d, a, x[k + 4], S24, 0xE7D3FBC8);
    md5_GG(ref a, b, c, d, x[k + 9], S21, 0x21E1CDE6);
    md5_GG(ref d, a, b, c, x[k + 14], S22, 0xC33707D6);
    md5_GG(ref c, d, a, b, x[k + 3], S23, 0xF4D50D87);
    md5_GG(ref b, c, d, a, x[k + 8], S24, 0x455A14ED);
    md5_GG(ref a, b, c, d, x[k + 13], S21, 0xA9E3E905);
    md5_GG(ref d, a, b, c, x[k + 2], S22, 0xFCEFA3F8);
    md5_GG(ref c, d, a, b, x[k + 7], S23, 0x676F02D9);
    md5_GG(ref b, c, d, a, x[k + 12], S24, 0x8D2A4C8A);
    md5_HH(ref a, b, c, d, x[k + 5], S31, 0xFFFA3942);
    md5_HH(ref d, a, b, c, x[k + 8], S32, 0x8771F681);
    md5_HH(ref c, d, a, b, x[k + 11], S33, 0x6D9D6122);
    md5_HH(ref b, c, d, a, x[k + 14], S34, 0xFDE5380C);
    md5_HH(ref a, b, c, d, x[k + 1], S31, 0xA4BEEA44);
    md5_HH(ref d, a, b, c, x[k + 4], S32, 0x4BDECFA9);
    md5_HH(ref c, d, a, b, x[k + 7], S33, 0xF6BB4B60);
    md5_HH(ref b, c, d, a, x[k + 10], S34, 0xBEBFBC70);
    md5_HH(ref a, b, c, d, x[k + 13], S31, 0x289B7EC6);
    md5_HH(ref d, a, b, c, x[k + 0], S32, 0xEAA127FA);
    md5_HH(ref c, d, a, b, x[k + 3], S33, 0xD4EF3085);
    md5_HH(ref b, c, d, a, x[k + 6], S34, 0x4881D05);
    md5_HH(ref a, b, c, d, x[k + 9], S31, 0xD9D4D039);
    md5_HH(ref d, a, b, c, x[k + 12], S32, 0xE6DB99E5);
    md5_HH(ref c, d, a, b, x[k + 15], S33, 0x1FA27CF8);
    md5_HH(ref b, c, d, a, x[k + 2], S34, 0xC4AC5665);
    md5_II(ref a, b, c, d, x[k + 0], S41, 0xF4292244);
    md5_II(ref d, a, b, c, x[k + 7], S42, 0x432AFF97);
    md5_II(ref c, d, a, b, x[k + 14], S43, 0xAB9423A7);
    md5_II(ref b, c, d, a, x[k + 5], S44, 0xFC93A039);
    md5_II(ref a, b, c, d, x[k + 12], S41, 0x655B59C3);
    md5_II(ref d, a, b, c, x[k + 3], S42, 0x8F0CCC92);
    md5_II(ref c, d, a, b, x[k + 10], S43, 0xFFEFF47D);
    md5_II(ref b, c, d, a, x[k + 1], S44, 0x85845DD1);
    md5_II(ref a, b, c, d, x[k + 8], S41, 0x6FA87E4F);
    md5_II(ref d, a, b, c, x[k + 15], S42, 0xFE2CE6E0);
    md5_II(ref c, d, a, b, x[k + 6], S43, 0xA3014314);
    md5_II(ref b, c, d, a, x[k + 13], S44, 0x4E0811A1);
    md5_II(ref a, b, c, d, x[k + 4], S41, 0xF7537E82);
    md5_II(ref d, a, b, c, x[k + 11], S42, 0xBD3AF235);
    md5_II(ref c, d, a, b, x[k + 2], S43, 0x2AD7D2BB);
    md5_II(ref b, c, d, a, x[k + 9], S44, 0xEB86D391);

    a = AddUnsigned(a, AA);
    b = AddUnsigned(b, BB);
    c = AddUnsigned(c, CC);
    d = AddUnsigned(d, DD);
   }

   if (stype == 32)
   {
    MD5 = ((((WordToHex(a)) + (WordToHex(b))) + (WordToHex(c))) + (WordToHex(d))).ToLower();
   }
   else
   {
    MD5 = ((WordToHex(b)) + (WordToHex(c))).ToLower();
   }
   return MD5;
  }
 }
}

 

]]>程序语言http://blog.careff.com/post/64.html#commenthttp://blog.careff.com/feed.asp?cmt=64Js地址编码防止中文出错误a@b.com (admin)http://blog.careff.com/post/60.htmlThu, 11 Sep 2008 10:26:17 +0800http://blog.careff.com/post/60.html字符URL编码：escape()

字符URL解码：unescape()

]]>程序语言http://blog.careff.com/post/60.html#commenthttp://blog.careff.com/feed.asp?cmt=60vb.net注册表操作a@b.com (admin)http://blog.careff.com/post/59.htmlThu, 11 Sep 2008 10:24:44 +0800http://blog.careff.com/post/59.htmlPublic Class RegClass
    Public Function UpRegData(ByVal IP As String) As Integer
        Try
            Dim regVersion As Microsoft.Win32.RegistryKey
            regVersion = _
           Microsoft.Win32.Registry.CurrentUser.OpenSubKey("要读、写的位置", True)
            If regVersion Is Nothing Then
                Return 0     'MessageBox.Show("不存在！")
            Else
                '存在
                regVersion.SetValue("要写的项的名称", "要写的值")
                Return 1  '写入成功
            End If
        Catch ex As Exception
            MessageBox.Show(ex.Message)
            Return -1   '出错
        End Try

    End Function
End Class

]]>程序语言http://blog.careff.com/post/59.html#commenthttp://blog.careff.com/feed.asp?cmt=59一个VB程序员应具备的基本工具列表a@b.com (admin)http://blog.careff.com/post/50.htmlThu, 11 Sep 2008 10:00:49 +0800http://blog.careff.com/post/50.htmlMsdnVB6.0 For VB 注,迷你Msdn足矣，你会问比如CreateWindow这样的Api去哪里查呢，Api是C的范围，在VB中只是调用，可以通过

API32.CHM 陈国强整理的,通过里面的中文学习别人是如何翻译英文的方法
Msdn2005是查询根源，多数的Api都可以查到方法。

下载页面  http://www.gougou.com/search?search=Msdn2005&id=0
当然找评论最多的那个下载了。

首先要成为VB中级程序员，你必须熟悉消息机制，具体可以看

http://www.sunxin.org/video/vc.asp

Lesson1：Windows程序运行原理及程序编写流程，窗口产生过程，句柄原理，消息队列，回调函数，窗口关闭与应用程序退出的工作关系，使用VC++的若干小技巧，stdcall与cdecl调用规范的比较，初学者常犯错误及注意事项。

仔细看Lesson1动画几次可以熟悉消息机制和子类化的来源，你说：我不懂Vc++怎么办，记住，没人生下来什么都懂，比尔开发微软时候也是自学的，具备亮剑精神就可以了。

当然你编程必须还需

中文spy++

.net提取的

有了这个，各位的问题应该少些了，自己spy............

http://www.vbgood.com/viewthread.php?tid=57926&extra=page%3D1


VB程序必备压缩工具

http://www.vbgood.com/viewthread ... =page%3D1#pid248191

VB源码之友

http://www.vbgood.com/viewthread.php?tid=58124&extra=page%3D1

Visual Basic实用编程标准(PDF)

http://www.codepub.com/Software/View-Software-1528.html

各位如果没规范编程方法的是时候纠正自己错误的习惯了，改的越早，对自己越好，切记，好的习惯终身享用。

1024个Windows消息

http://www.vbgood.com/viewthread.php?tid=64084

自编ERRLOOK

http://www.vbgood.com/viewthread.php?tid=64023

API声明常量补充之源->>API.net

http://www.vbgood.com/viewthread.php?tid=63919

MSVB6.0中文企业版，不要装迷你版本，因为你会遇到许多麻烦。

点这里尽快下载

金山词霸2007专业版本，这个去百度找破解版本吧。

当你调试程序你必然要和指针到交道,这两兄弟都需要

WinHex v14.1 SR-6 简体中文版,文件修改和内存编辑

http://fixdown.com/china/Application/5845.htm     

UltraEdit

http://www.fixdown.com/china/Application/3704.htm

Winxp自带计算器，切换到16进制方式，有些人喜欢用幻数。

API中文范例

本来是绿色版本，由于文件太大我过滤了MSCOMCTL.Ocx，因为我当年打包的时候里面ocx有些是系统没有的，所以加在一起做了绿色版本。这个例子程序的数量应该是当前网上最多的

本地下载

VB有许多和Api比拼的函数，用好它们吧

Visual Basic 语言参考-函数速查


 

]]>程序语言http://blog.careff.com/post/50.html#commenthttp://blog.careff.com/feed.asp?cmt=50