使用纯真版IP地址库，根据IP判断所在地

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Text.RegularExpressions;
using System.IO;

public  partial  class ip_getip : System.Web.UI.Page
{
     protected  void Page_Load( object sender, EventArgs e)
    {
        
         for ( int i =  0; i <  100; i++)
        {
             int seed = Math.Abs(( int)BitConverter.ToUInt32(Guid.NewGuid().ToByteArray(),  0));
            Random a =  new Random(seed);
             string ip1 = a.Next( 1,  255).ToString();
             string ip2 = a.Next( 1,  255).ToString();
             string ip3 = a.Next( 1,  255).ToString();
             string ip4 = a.Next( 1,  255).ToString();

             string ip =  " 61.177.7.1 ";

             string c2 = IpSearch.GetAddressWithIP(ip) ==  "" ?  " 未知地址 " : IpSearch.GetAddressWithIP(ip);

            Response.Write( " IP: " + ip);
            Response.Write( " 地址： " + c2 +  " <br/> ");
        }

    
    }


     ///   <summary>
     ///  获得当前页面客户端的IP
     ///   </summary>
     ///   <returns> 当前页面客户端的IP </returns>
     public   string GetIP()
    {
         string result = HttpContext.Current.Request.ServerVariables[ " REMOTE_ADDR "];
         if ( string.IsNullOrEmpty(result))
            result = HttpContext.Current.Request.ServerVariables[ " HTTP_X_FORWARDED_FOR "];

         if ( string.IsNullOrEmpty(result))
            result = HttpContext.Current.Request.UserHostAddress;

         if ( string.IsNullOrEmpty(result) || !IsIP(result))
             return  " 127.0.0.1 ";

         return result;
    }

     ///   <summary>
     ///  是否为ip
     ///   </summary>
     ///   <param name="ip"></param>
     ///   <returns></returns>
     public   bool IsIP( string ip)
    {
         return Regex.IsMatch(ip,  @" ^((2[0-4]\d|25[0-5]|[01]?\d\d?)\.){3}(2[0-4]\d|25[0-5]|[01]?\d\d?)$ ");
    }



}



///   <summary>
///  判断IP归属地类
///   </summary>
public  class IpSearch
{

     ///   <summary>
     ///  获得当前绝对路径
     ///   </summary>
     ///   <param name="strPath"> 指定的路径 </param>
     ///   <returns> 绝对路径 </returns>
     public  static   string GetMapPath( string strPath)
    {
         if (HttpContext.Current !=  null)
        {
             return HttpContext.Current.Server.MapPath(strPath);
        }
         else  // 非web程序引用
        {
            strPath = strPath.Replace( " / ",  " \\ ");
             if (strPath.StartsWith( " \\ "))
            {
                strPath = strPath.Substring(strPath.IndexOf( ' \\ ',  1)).TrimStart( ' \\ ');
            }
             return System.IO.Path.Combine(AppDomain.CurrentDomain.BaseDirectory, strPath);
        }
    }
     ///   <summary>
     ///  返回文件是否存在
     ///   </summary>
     ///   <param name="filename"> 文件名 </param>
     ///   <returns> 是否存在 </returns>
     public  static  bool FileExists( string filename)
    {
         return System.IO.File.Exists(filename);
    }




     private  static  object lockHelper =  new  object();

     static PHCZIP pcz =  new PHCZIP();

     static  string filePath =  "";

     static  bool fileIsExsit =  true;

     static IpSearch()
    {
         string ipdatadir =   " ~/ip ";
     

        filePath = GetMapPath(ipdatadir +  " /ipdata.config "); //qqwry.dat直接改名即可
        fileIsExsit = FileExists(filePath);

         if (fileIsExsit)
        {
            pcz.SetDbFilePath(filePath);
        }
    }

     ///   <summary>
     ///  返回IP查找结果
     ///   </summary>
     ///   <param name="IPValue"> 要查找的IP地址 </param>
     ///   <returns></returns>
     public  static  string GetAddressWithIP( string IPValue)
    {
         lock (lockHelper)
        {
             string result = pcz.GetAddressWithIP(IPValue.Trim());

             if (fileIsExsit)
            {
                 if (result.IndexOf( " IANA ") >=  0)
                     return  "";
                 else
                     return result;
            }
             else
                 return  null;
        }
    }

     ///   <summary>
     ///  辅助类，用于保存IP索引信息
     ///   </summary>
     ///      
     public  class CZ_INDEX_INFO
    {
         public UInt32 IpSet;
         public UInt32 IpEnd;
         public UInt32 Offset;

         public CZ_INDEX_INFO()
        {
            IpSet =  0;
            IpEnd =  0;
            Offset =  0;
        }
    }

     // 读取纯真IP数据库类
     public  class PHCZIP
    {
         protected  bool bFilePathInitialized;
         protected  string FilePath;
         protected FileStream FileStrm;
         protected UInt32 Index_Set;
         protected UInt32 Index_End;
         protected UInt32 Index_Count;
         protected UInt32 Search_Index_Set;
         protected UInt32 Search_Index_End;
         protected CZ_INDEX_INFO Search_Set;
         protected CZ_INDEX_INFO Search_Mid;
         protected CZ_INDEX_INFO Search_End;

         public PHCZIP()
        {
            bFilePathInitialized =  false;
        }

         public PHCZIP( string dbFilePath)
        {
            bFilePathInitialized =  false;
            SetDbFilePath(dbFilePath);
        }

         // 使用二分法查找索引区，初始化查找区间
         public  void Initialize()
        {
            Search_Index_Set =  0;
            Search_Index_End = Index_Count -  1;
        }

         // 关闭文件
         public  void Dispose()
        {
             if (bFilePathInitialized)
            {
                bFilePathInitialized =  false;
                FileStrm.Close();
                 // FileStrm.Dispose();
            }
        }


         public  bool SetDbFilePath( string dbFilePath)
        {
             if (dbFilePath ==  "")
                 return  false;

             try
            {
                FileStrm =  new FileStream(dbFilePath, FileMode.Open, FileAccess.Read, FileShare.Read);
            }
             catch
            {
                 return  false;
            }
             // 检查文件长度
             if (FileStrm.Length <  8)
            {
                FileStrm.Close();
                 // FileStrm.Dispose();
                 return  false;
            }
             // 得到第一条索引的绝对偏移和最后一条索引的绝对偏移
            FileStrm.Seek( 0, SeekOrigin.Begin);
            Index_Set = GetUInt32();
            Index_End = GetUInt32();

             // 得到总索引条数
            Index_Count = (Index_End - Index_Set) /  7 +  1;
            bFilePathInitialized =  true;

             return  true;
        }

         public  string GetAddressWithIP( string IPValue)
        {
             if (!bFilePathInitialized)
                 return  "";

            Initialize();
            UInt32 ip = IPToUInt32(IPValue);

             while ( true)
            {

                 // 首先初始化本轮查找的区间

                 // 区间头
                Search_Set = IndexInfoAtPos(Search_Index_Set);
                 // 区间尾
                Search_End = IndexInfoAtPos(Search_Index_End);

                 // 判断IP是否在区间头内
                 if (ip >= Search_Set.IpSet && ip <= Search_Set.IpEnd)
                     return ReadAddressInfoAtOffset(Search_Set.Offset);


                 // 判断IP是否在区间尾内
                 if (ip >= Search_End.IpSet && ip <= Search_End.IpEnd)
                     return ReadAddressInfoAtOffset(Search_End.Offset);

                 // 计算出区间中点
                Search_Mid = IndexInfoAtPos((Search_Index_End + Search_Index_Set) /  2);

                 // 判断IP是否在中点
                 if (ip >= Search_Mid.IpSet && ip <= Search_Mid.IpEnd)
                     return ReadAddressInfoAtOffset(Search_Mid.Offset);

                 // 本轮没有找到，准备下一轮
                 if (ip < Search_Mid.IpSet)
                     // IP比区间中点要小，将区间尾设为现在的中点，将区间缩小1倍。
                    Search_Index_End = (Search_Index_End + Search_Index_Set) /  2;
                 else
                     // IP比区间中点要大，将区间头设为现在的中点，将区间缩小1倍。
                    Search_Index_Set = (Search_Index_End + Search_Index_Set) /  2;
            }
        }

         private  string ReadAddressInfoAtOffset(UInt32 Offset)
        {
             string country =  "";
             string area =  "";
            UInt32 country_Offset =  0;
             byte Tag =  0;
             // 跳过4字节，因这4个字节是该索引的IP区间上限。
            FileStrm.Seek(Offset +  4, SeekOrigin.Begin);

             // 读取一个字节，得到描述国家信息的“寻址方式”
            Tag = GetTag();

             if (Tag ==  0x01)
            {
                 // 模式0x01，表示接下来的3个字节是表示偏移位置
                FileStrm.Seek(GetOffset(), SeekOrigin.Begin);

                 // 继续检查“寻址方式”
                Tag = GetTag();
                 if (Tag ==  0x02)
                {
                     // 模式0x02，表示接下来的3个字节代表国家信息的偏移位置
                     // 先将这个偏移位置保存起来，因为我们要读取它后面的地区信息。
                    country_Offset = GetOffset();
                     // 读取地区信息（注：按照Luma的说明，好像没有这么多种可能性，但在测试过程中好像有些情况没有考虑到，
                     // 所以写了个ReadArea()来读取。
                    area = ReadArea();
                     // 读取国家信息
                    FileStrm.Seek(country_Offset, SeekOrigin.Begin);
                    country = ReadString();
                }
                 else
                {
                     // 这种模式说明接下来就是保存的国家和地区信息了，以'\0'代表结束。
                    FileStrm.Seek(- 1, SeekOrigin.Current);
                    country = ReadString();
                    area = ReadArea();

                }
            }
             else  if (Tag ==  0x02)
            {
                 // 模式0x02，说明国家信息是一个偏移位置
                country_Offset = GetOffset();
                 // 先读取地区信息
                area = ReadArea();
                 // 读取国家信息
                FileStrm.Seek(country_Offset, SeekOrigin.Begin);
                country = ReadString();
            }
             else
            {
                 // 这种模式最简单了，直接读取国家和地区就OK了
                FileStrm.Seek(- 1, SeekOrigin.Current);
                country = ReadString();
                area = ReadArea();
            }
             return country +  "   " + area;
        }

         private UInt32 GetOffset()
        {
             byte[] TempByte4 =  new  byte[ 4];
            TempByte4[ 0] = ( byte)FileStrm.ReadByte();
            TempByte4[ 1] = ( byte)FileStrm.ReadByte();
            TempByte4[ 2] = ( byte)FileStrm.ReadByte();
            TempByte4[ 3] =  0;
             return BitConverter.ToUInt32(TempByte4,  0);
        }

         protected  string ReadArea()
        {
             byte Tag = GetTag();

             if (Tag ==  0x01 || Tag ==  0x02)
                FileStrm.Seek(GetOffset(), SeekOrigin.Begin);
             else
                FileStrm.Seek(- 1, SeekOrigin.Current);

             return ReadString();
        }

         protected  string ReadString()
        {
            UInt32 Offset =  0;
             byte[] TempByteArray =  new  byte[ 256];
            TempByteArray[Offset] = ( byte)FileStrm.ReadByte();
             while (TempByteArray[Offset] !=  0x00)
            {
                Offset +=  1;
                TempByteArray[Offset] = ( byte)FileStrm.ReadByte();
            }
             return System.Text.Encoding.GetEncoding( " GB2312 ").GetString(TempByteArray).TrimEnd( ' \0 ');
        }

         protected  byte GetTag()
        {
             return ( byte)FileStrm.ReadByte();
        }

         protected CZ_INDEX_INFO IndexInfoAtPos(UInt32 Index_Pos)
        {
            CZ_INDEX_INFO Index_Info =  new CZ_INDEX_INFO();
             // 根据索引编号计算出在文件中在偏移位置
            FileStrm.Seek(Index_Set +  7 * Index_Pos, SeekOrigin.Begin);
            Index_Info.IpSet = GetUInt32();
            Index_Info.Offset = GetOffset();
            FileStrm.Seek(Index_Info.Offset, SeekOrigin.Begin);
            Index_Info.IpEnd = GetUInt32();

             return Index_Info;
        }

         ///   <summary>
         ///  从IP转换为Int32
         ///   </summary>
         ///   <param name="IpValue"></param>
         ///   <returns></returns>
         public UInt32 IPToUInt32( string IpValue)
        {
             string[] IpByte = IpValue.Split( ' . ');
            Int32 nUpperBound = IpByte.GetUpperBound( 0);
             if (nUpperBound !=  3)
            {
                IpByte =  new  string[ 4];
                 for (Int32 i =  1; i <=  3 - nUpperBound; i++)
                    IpByte[nUpperBound + i] =  " 0 ";
            }

             byte[] TempByte4 =  new  byte[ 4];
             for (Int32 i =  0; i <=  3; i++)
            {
                 if (IsNumeric(IpByte[i]))
                    TempByte4[ 3 - i] = ( byte)(Convert.ToInt32(IpByte[i]) &  0xff);
            }

             return BitConverter.ToUInt32(TempByte4,  0);
        }

         ///   <summary>
         ///  判断是否为数字
         ///   </summary>
         ///   <param name="str"> 待判断字符串 </param>
         ///   <returns></returns>
         protected  bool IsNumeric( string str)
        {
             if (str !=  null && System.Text.RegularExpressions.Regex.IsMatch(str,  @" ^-?\d+$ "))
                 return  true;
             else
                 return  false;
        }

         protected UInt32 GetUInt32()
        {
             byte[] TempByte4 =  new  byte[ 4];
            FileStrm.Read(TempByte4,  0,  4);
             return BitConverter.ToUInt32(TempByte4,  0);
        }
    }
}

 

 

 

将地址库转SQL:

http://www.cnblogs.com/hejunrex/archive/2011/11/28/2266055.html