中文字幕免费精品_亚洲视频自拍_亚洲综合国产激情另类一区_色综合咪咪久久

asp.net DataTable相關操作集錦(篩選,取前N條數據,去重復行,獲取指定列數據等)
來源:易賢網 閱讀:2169 次 日期:2016-08-08 14:08:24
溫馨提示:易賢網小編為您整理了“asp.net DataTable相關操作集錦(篩選,取前N條數據,去重復行,獲取指定列數據等)”,方便廣大網友查閱!

本文實例總結了asp.net DataTable相關操作。分享給大家供大家參考,具體如下:

#region DataTable篩選,排序返回符合條件行組成的新DataTable或直接用DefaultView按條件返回

/// <summary>

/// DataTable篩選,排序返回符合條件行組成的新DataTable或直接用DefaultView按條件返回

/// eg:SortExprDataTable(dt,"Sex='男'","Time Desc",1)

/// </summary>

/// <param name="dt">傳入的DataTable</param>

/// <param name="strExpr">篩選條件</param>

/// <param name="strSort">排序條件</param>

/// <param name="mode">1,直接用DefaultView按條件返回,效率較高;2,DataTable篩選,排序返回符合條件行組成的新DataTable</param>

public static DataTable SortDataTable(DataTable dt, string strExpr, string strSort, int mode)

{

  switch (mode)

  {

    case 1:

      //方法一 直接用DefaultView按條件返回

      dt.DefaultView.RowFilter = strExpr;

      dt.DefaultView.Sort = strSort;

      return dt;

    case 2:

      //方法二 DataTable篩選,排序返回符合條件行組成的新DataTable

      DataTable dt1 = new DataTable();

      DataRow[] GetRows = dt.Select(strExpr, strSort);

      //復制DataTable dt結構不包含數據

      dt1 = dt.Clone();

      foreach (DataRow row in GetRows)

      {

        dt1.Rows.Add(row.ItemArray);

      }

      return dt1;

    default:

      return dt;

  }

}

#endregion

---------------------------------------

#region 獲取DataTable前幾條數據

/// <summary>

/// 獲取DataTable前幾條數據

/// </summary>

/// <param name="TopItem">前N條數據</param>

/// <param name="oDT">源DataTable</param>

/// <returns></returns>

public static DataTable DtSelectTop(int TopItem, DataTable oDT)

{

  if (oDT.Rows.Count < TopItem) return oDT;

  DataTable NewTable = oDT.Clone();

  DataRow[] rows = oDT.Select("1=1");

  for (int i = 0; i < TopItem; i++)

  {

    NewTable.ImportRow((DataRow)rows[i]);

  }

  return NewTable;

}

#endregion

----------------------------------------------

#region 獲取DataTable中指定列的數據

/// <summary>

/// 獲取DataTable中指定列的數據

/// </summary>

/// <param name="dt">數據源</param>

/// <param name="tableName">新的DataTable的名詞</param>

/// <param name="strColumns">指定的列名集合</param>

/// <returns>返回新的DataTable</returns>

public static DataTable GetTableColumn(DataTable dt, string tableName, params string[] strColumns)

{

  DataTable dtn = new DataTable();

  if (dt == null)

  {

    throw new ArgumentNullException("參數dt不能為null");

  }

  try

  {

    dtn = dt.DefaultView.ToTable(tableName, true, strColumns);

  }

  catch (Exception e)

  {

    throw new Exception(e.Message);

  }

  return dtn;

}

#endregion

--------------------------------------------

using System;

using System.Collections.Generic;

using System.Linq;

using System.Data;

using System.Collections;

using System.Text;

namespace GuanEasy

{

 /// <summary>

  /// DataSet助手

  /// </summary>

  public class DataSetHelper

  {

    private class FieldInfo

    {

      public string RelationName;

      public string FieldName;

      public string FieldAlias;

      public string Aggregate;

    }

    private DataSet ds;

    private ArrayList m_FieldInfo;

    private string m_FieldList;

    private ArrayList GroupByFieldInfo;

    private string GroupByFieldList;

    public DataSet DataSet

    {

      get { return ds; }

    }

    #region Construction

    public DataSetHelper()

    {

      ds = null;

    }

    public DataSetHelper(ref DataSet dataSet)

    {

      ds = dataSet;

    }

    #endregion

    #region Private Methods

    private bool ColumnEqual(object objectA, object objectB)

    {

      if ( objectA == DBNull.Value && objectB == DBNull.Value )

      {

        return true;

      }

      if ( objectA == DBNull.Value || objectB == DBNull.Value )

      {

        return false;

      }

      return ( objectA.Equals( objectB ) );

    }

    private bool RowEqual(DataRow rowA, DataRow rowB, DataColumnCollection columns)

    {

      bool result = true;

      for ( int i = 0; i < columns.Count; i++ )

      {

        result &= ColumnEqual( rowA[ columns[ i ].ColumnName ], rowB[ columns[ i ].ColumnName ] );

      }

      return result;

    }

    private void ParseFieldList(string fieldList, bool allowRelation)

    {

      if ( m_FieldList == fieldList )

      {

        return;

      }

      m_FieldInfo = new ArrayList();

      m_FieldList = fieldList;

      FieldInfo Field;

      string[] FieldParts;

      string[] Fields = fieldList.Split( ',' );

      for ( int i = 0; i <= Fields.Length - 1; i++ )

      {

        Field = new FieldInfo();

        FieldParts = Fields[ i ].Trim().Split( ' ' );

        switch ( FieldParts.Length )

        {

          case 1:

            //to be set at the end of the loop

            break;

          case 2:

            Field.FieldAlias = FieldParts[ 1 ];

            break;

          default:

            return;

        }

        FieldParts = FieldParts[ 0 ].Split( '.' );

        switch ( FieldParts.Length )

        {

          case 1:

            Field.FieldName = FieldParts[ 0 ];

            break;

          case 2:

            if ( allowRelation == false )

            {

              return;

            }

            Field.RelationName = FieldParts[ 0 ].Trim();

            Field.FieldName = FieldParts[ 1 ].Trim();

            break;

          default:

            return;

        }

        if ( Field.FieldAlias == null )

        {

          Field.FieldAlias = Field.FieldName;

        }

        m_FieldInfo.Add( Field );

      }

    }

    private DataTable CreateTable(string tableName, DataTable sourceTable, string fieldList)

    {

      DataTable dt;

      if ( fieldList.Trim() == "" )

      {

        dt = sourceTable.Clone();

        dt.TableName = tableName;

      }

      else

      {

        dt = new DataTable( tableName );

        ParseFieldList( fieldList, false );

        DataColumn dc;

        foreach ( FieldInfo Field in m_FieldInfo )

        {

          dc = sourceTable.Columns[ Field.FieldName ];

          DataColumn column = new DataColumn();

          column.ColumnName = Field.FieldAlias;

          column.DataType = dc.DataType;

          column.MaxLength = dc.MaxLength;

          column.Expression = dc.Expression;

          dt.Columns.Add( column );

        }

      }

      if ( ds != null )

      {

        ds.Tables.Add( dt );

      }

      return dt;

    }

    private void InsertInto(DataTable destTable, DataTable sourceTable,

                string fieldList, string rowFilter, string sort)

    {

      ParseFieldList( fieldList, false );

      DataRow[] rows = sourceTable.Select( rowFilter, sort );

      DataRow destRow;

      foreach ( DataRow sourceRow in rows )

      {

        destRow = destTable.NewRow();

        if ( fieldList == "" )

        {

          foreach ( DataColumn dc in destRow.Table.Columns )

          {

            if ( dc.Expression == "" )

            {

              destRow[ dc ] = sourceRow[ dc.ColumnName ];

            }

          }

        }

        else

        {

          foreach ( FieldInfo field in m_FieldInfo )

          {

            destRow[ field.FieldAlias ] = sourceRow[ field.FieldName ];

          }

        }

        destTable.Rows.Add( destRow );

      }

    }

    private void ParseGroupByFieldList(string FieldList)

    {

      if ( GroupByFieldList == FieldList )

      {

        return;

      }

      GroupByFieldInfo = new ArrayList();

      FieldInfo Field;

      string[] FieldParts;

      string[] Fields = FieldList.Split( ',' );

      for ( int i = 0; i <= Fields.Length - 1; i++ )

      {

        Field = new FieldInfo();

        FieldParts = Fields[ i ].Trim().Split( ' ' );

        switch ( FieldParts.Length )

        {

          case 1:

            //to be set at the end of the loop

            break;

          case 2:

            Field.FieldAlias = FieldParts[ 1 ];

            break;

          default:

            return;

        }

        FieldParts = FieldParts[ 0 ].Split( '(' );

        switch ( FieldParts.Length )

        {

          case 1:

            Field.FieldName = FieldParts[ 0 ];

            break;

          case 2:

            Field.Aggregate = FieldParts[ 0 ].Trim().ToLower();

            Field.FieldName = FieldParts[ 1 ].Trim( ' ', ')' );

            break;

          default:

            return;

        }

        if ( Field.FieldAlias == null )

        {

          if ( Field.Aggregate == null )

          {

            Field.FieldAlias = Field.FieldName;

          }

          else

          {

            Field.FieldAlias = Field.Aggregate + "of" + Field.FieldName;

          }

        }

        GroupByFieldInfo.Add( Field );

      }

      GroupByFieldList = FieldList;

    }

    private DataTable CreateGroupByTable(string tableName, DataTable sourceTable, string fieldList)

    {

      if ( fieldList == null || fieldList.Length == 0 )

      {

        return sourceTable.Clone();

      }

      else

      {

        DataTable dt = new DataTable( tableName );

        ParseGroupByFieldList( fieldList );

        foreach ( FieldInfo Field in GroupByFieldInfo )

        {

          DataColumn dc = sourceTable.Columns[ Field.FieldName ];

          if ( Field.Aggregate == null )

          {

            dt.Columns.Add( Field.FieldAlias, dc.DataType, dc.Expression );

          }

          else

          {

            dt.Columns.Add( Field.FieldAlias, dc.DataType );

          }

        }

        if ( ds != null )

        {

          ds.Tables.Add( dt );

        }

        return dt;

      }

    }

    private void InsertGroupByInto(DataTable destTable, DataTable sourceTable, string fieldList,

                    string rowFilter, string groupBy)

    {

      if ( fieldList == null || fieldList.Length == 0 )

      {

        return;

      }

      ParseGroupByFieldList( fieldList );

      ParseFieldList( groupBy, false );

      DataRow[] rows = sourceTable.Select( rowFilter, groupBy );

      DataRow lastSourceRow = null, destRow = null;

      bool sameRow;

      int rowCount = 0;

      foreach ( DataRow sourceRow in rows )

      {

        sameRow = false;

        if ( lastSourceRow != null )

        {

          sameRow = true;

          foreach ( FieldInfo Field in m_FieldInfo )

          {

            if ( !ColumnEqual( lastSourceRow[ Field.FieldName ], sourceRow[ Field.FieldName ] ) )

            {

              sameRow = false;

              break;

            }

          }

          if ( !sameRow )

          {

            destTable.Rows.Add( destRow );

          }

        }

        if ( !sameRow )

        {

          destRow = destTable.NewRow();

          rowCount = 0;

        }

        rowCount += 1;

        foreach ( FieldInfo field in GroupByFieldInfo )

        {

          switch ( field.Aggregate.ToLower() )

          {

            case null:

            case "":

            case "last":

              destRow[ field.FieldAlias ] = sourceRow[ field.FieldName ];

              break;

            case "first":

              if ( rowCount == 1 )

              {

                destRow[ field.FieldAlias ] = sourceRow[ field.FieldName ];

              }

              break;

            case "count":

              destRow[ field.FieldAlias ] = rowCount;

              break;

            case "sum":

              destRow[ field.FieldAlias ] = Add( destRow[ field.FieldAlias ], sourceRow[ field.FieldName ] );

              break;

            case "max":

              destRow[ field.FieldAlias ] = Max( destRow[ field.FieldAlias ], sourceRow[ field.FieldName ] );

              break;

            case "min":

              if ( rowCount == 1 )

              {

                destRow[ field.FieldAlias ] = sourceRow[ field.FieldName ];

              }

              else

              {

                destRow[ field.FieldAlias ] = Min( destRow[ field.FieldAlias ], sourceRow[ field.FieldName ] );

              }

              break;

          }

        }

        lastSourceRow = sourceRow;

      }

      if ( destRow != null )

      {

        destTable.Rows.Add( destRow );

      }

    }

    private object Min(object a, object b)

    {

      if ( ( a is DBNull ) || ( b is DBNull ) )

      {

        return DBNull.Value;

      }

      if ( ( (IComparable) a ).CompareTo( b ) == -1 )

      {

        return a;

      }

      else

      {

        return b;

      }

    }

    private object Max(object a, object b)

    {

      if ( a is DBNull )

      {

        return b;

      }

      if ( b is DBNull )

      {

        return a;

      }

      if ( ( (IComparable) a ).CompareTo( b ) == 1 )

      {

        return a;

      }

      else

      {

        return b;

      }

    }

    private object Add(object a, object b)

    {

      if ( a is DBNull )

      {

        return b;

      }

      if ( b is DBNull )

      {

        return a;

      }

      return ( (decimal) a + (decimal) b );

    }

    private DataTable CreateJoinTable(string tableName, DataTable sourceTable, string fieldList)

    {

      if ( fieldList == null )

      {

        return sourceTable.Clone();

      }

      else

      {

        DataTable dt = new DataTable( tableName );

        ParseFieldList( fieldList, true );

        foreach ( FieldInfo field in m_FieldInfo )

        {

          if ( field.RelationName == null )

          {

            DataColumn dc = sourceTable.Columns[ field.FieldName ];

            dt.Columns.Add( dc.ColumnName, dc.DataType, dc.Expression );

          }

          else

          {

            DataColumn dc = sourceTable.ParentRelations[ field.RelationName ].ParentTable.Columns[ field.FieldName ];

            dt.Columns.Add( dc.ColumnName, dc.DataType, dc.Expression );

          }

        }

        if ( ds != null )

        {

          ds.Tables.Add( dt );

        }

        return dt;

      }

    }

    private void InsertJoinInto(DataTable destTable, DataTable sourceTable,

                  string fieldList, string rowFilter, string sort)

    {

      if ( fieldList == null )

      {

        return;

      }

      else

      {

        ParseFieldList( fieldList, true );

        DataRow[] Rows = sourceTable.Select( rowFilter, sort );

        foreach ( DataRow SourceRow in Rows )

        {

          DataRow DestRow = destTable.NewRow();

          foreach ( FieldInfo Field in m_FieldInfo )

          {

            if ( Field.RelationName == null )

            {

              DestRow[ Field.FieldName ] = SourceRow[ Field.FieldName ];

            }

            else

            {

              DataRow ParentRow = SourceRow.GetParentRow( Field.RelationName );

              DestRow[ Field.FieldName ] = ParentRow[ Field.FieldName ];

            }

          }

          destTable.Rows.Add( DestRow );

        }

      }

    }

    #endregion

    #region SelectDistinct / Distinct

    /// <summary>

    /// 按照fieldName從sourceTable中選擇出不重復的行,

    /// 相當于select distinct fieldName from sourceTable

    /// </summary>

    /// <param name="tableName">表名</param>

    /// <param name="sourceTable">源DataTable</param>

    /// <param name="fieldName">列名</param>

    /// <returns>一個新的不含重復行的DataTable,列只包括fieldName指明的列</returns>

    public DataTable SelectDistinct(string tableName, DataTable sourceTable, string fieldName)

    {

      DataTable dt = new DataTable( tableName );

      dt.Columns.Add( fieldName, sourceTable.Columns[ fieldName ].DataType );

      object lastValue = null;

      foreach ( DataRow dr in sourceTable.Select( "", fieldName ) )

      {

        if ( lastValue == null || !( ColumnEqual( lastValue, dr[ fieldName ] ) ) )

        {

          lastValue = dr[ fieldName ];

          dt.Rows.Add( new object[]{lastValue} );

        }

      }

      if ( ds != null && !ds.Tables.Contains( tableName ) )

      {

        ds.Tables.Add( dt );

      }

      return dt;

    }

    /// <summary>

    /// 按照fieldName從sourceTable中選擇出不重復的行,

    /// 相當于select distinct fieldName1,fieldName2,,fieldNamen from sourceTable

    /// </summary>

    /// <param name="tableName">表名</param>

    /// <param name="sourceTable">源DataTable</param>

    /// <param name="fieldNames">列名數組</param>

    /// <returns>一個新的不含重復行的DataTable,列只包括fieldNames中指明的列</returns>

    public DataTable SelectDistinct(string tableName, DataTable sourceTable, string[] fieldNames)

    {

      DataTable dt = new DataTable( tableName );

      object[] values = new object[fieldNames.Length];

      string fields = "";

      for ( int i = 0; i < fieldNames.Length; i++ )

      {

        dt.Columns.Add( fieldNames[ i ], sourceTable.Columns[ fieldNames[ i ] ].DataType );

        fields += fieldNames[ i ] + ",";

      }

      fields = fields.Remove( fields.Length - 1, 1 );

      DataRow lastRow = null;

      foreach ( DataRow dr in sourceTable.Select( "", fields ) )

      {

        if ( lastRow == null || !( RowEqual( lastRow, dr, dt.Columns ) ) )

        {

          lastRow = dr;

          for ( int i = 0; i < fieldNames.Length; i++ )

          {

            values[ i ] = dr[ fieldNames[ i ] ];

          }

          dt.Rows.Add( values );

        }

      }

      if ( ds != null && !ds.Tables.Contains( tableName ) )

      {

        ds.Tables.Add( dt );

      }

      return dt;

    }

    /// <summary>

    /// 按照fieldName從sourceTable中選擇出不重復的行,

    /// 并且包含sourceTable中所有的列。

    /// </summary>

    /// <param name="tableName">表名</param>

    /// <param name="sourceTable">源表</param>

    /// <param name="fieldName">字段</param>

    /// <returns>一個新的不含重復行的DataTable</returns>

    public DataTable Distinct(string tableName, DataTable sourceTable, string fieldName)

    {

      DataTable dt = sourceTable.Clone();

      dt.TableName = tableName;

      object lastValue = null;

      foreach ( DataRow dr in sourceTable.Select( "", fieldName ) )

      {

        if ( lastValue == null || !( ColumnEqual( lastValue, dr[ fieldName ] ) ) )

        {

          lastValue = dr[ fieldName ];

          dt.Rows.Add( dr.ItemArray );

        }

      }

      if ( ds != null && !ds.Tables.Contains( tableName ) )

      {

        ds.Tables.Add( dt );

      }

      return dt;

    }

    /// <summary>

    /// 按照fieldNames從sourceTable中選擇出不重復的行,

    /// 并且包含sourceTable中所有的列。

    /// </summary>

    /// <param name="tableName">表名</param>

    /// <param name="sourceTable">源表</param>

    /// <param name="fieldNames">字段</param>

    /// <returns>一個新的不含重復行的DataTable</returns>

    public DataTable Distinct(string tableName, DataTable sourceTable, string[] fieldNames)

    {

      DataTable dt = sourceTable.Clone();

      dt.TableName = tableName;

      string fields = "";

      for ( int i = 0; i < fieldNames.Length; i++ )

      {

        fields += fieldNames[ i ] + ",";

      }

      fields = fields.Remove( fields.Length - 1, 1 );

      DataRow lastRow = null;

      foreach ( DataRow dr in sourceTable.Select( "", fields ) )

      {

        if ( lastRow == null || !( RowEqual( lastRow, dr, dt.Columns ) ) )

        {

          lastRow = dr;

          dt.Rows.Add( dr.ItemArray );

        }

      }

      if ( ds != null && !ds.Tables.Contains( tableName ) )

      {

        ds.Tables.Add( dt );

      }

      return dt;

    }

    #endregion

    #region Select Table Into

    /// <summary>

    /// 按sort排序,按rowFilter過濾sourceTable,

    /// 復制fieldList中指明的字段的數據到新DataTable,并返回之

    /// </summary>

    /// <param name="tableName">表名</param>

    /// <param name="sourceTable">源表</param>

    /// <param name="fieldList">字段列表</param>

    /// <param name="rowFilter">過濾條件</param>

    /// <param name="sort">排序</param>

    /// <returns>新DataTable</returns>

    public DataTable SelectInto(string tableName, DataTable sourceTable,

                  string fieldList, string rowFilter, string sort)

    {

      DataTable dt = CreateTable( tableName, sourceTable, fieldList );

      InsertInto( dt, sourceTable, fieldList, rowFilter, sort );

      return dt;

    }

    #endregion

    #region Group By Table

    public DataTable SelectGroupByInto(string tableName, DataTable sourceTable, string fieldList,

                      string rowFilter, string groupBy)

    {

      DataTable dt = CreateGroupByTable( tableName, sourceTable, fieldList );

      InsertGroupByInto( dt, sourceTable, fieldList, rowFilter, groupBy );

      return dt;

    }

    #endregion

    #region Join Tables

    public DataTable SelectJoinInto(string tableName, DataTable sourceTable, string fieldList, string rowFilter, string sort)

    {

      DataTable dt = CreateJoinTable( tableName, sourceTable, fieldList );

      InsertJoinInto( dt, sourceTable, fieldList, rowFilter, sort );

      return dt;

    }

    #endregion

    #region Create Table

    public DataTable CreateTable(string tableName, string fieldList)

    {

      DataTable dt = new DataTable( tableName );

      DataColumn dc;

      string[] Fields = fieldList.Split( ',' );

      string[] FieldsParts;

      string Expression;

      foreach ( string Field in Fields )

      {

        FieldsParts = Field.Trim().Split( " ".ToCharArray(), 3 ); // allow for spaces in the expression

        // add fieldname and datatype

        if ( FieldsParts.Length == 2 )

        {

          dc = dt.Columns.Add( FieldsParts[ 0 ].Trim(), Type.GetType( "System." + FieldsParts[ 1 ].Trim(), true, true ) );

          dc.AllowDBNull = true;

        }

        else if ( FieldsParts.Length == 3 ) // add fieldname, datatype, and expression

        {

          Expression = FieldsParts[ 2 ].Trim();

          if ( Expression.ToUpper() == "REQUIRED" )

          {

            dc = dt.Columns.Add( FieldsParts[ 0 ].Trim(), Type.GetType( "System." + FieldsParts[ 1 ].Trim(), true, true ) );

            dc.AllowDBNull = false;

          }

          else

          {

            dc = dt.Columns.Add( FieldsParts[ 0 ].Trim(), Type.GetType( "System." + FieldsParts[ 1 ].Trim(), true, true ), Expression );

          }

        }

        else

        {

          return null;

        }

      }

      if ( ds != null )

      {

        ds.Tables.Add( dt );

      }

      return dt;

    }

    public DataTable CreateTable(string tableName, string fieldList, string keyFieldList)

    {

      DataTable dt = CreateTable( tableName, fieldList );

      string[] KeyFields = keyFieldList.Split( ',' );

      if ( KeyFields.Length > 0 )

      {

        DataColumn[] KeyFieldColumns = new DataColumn[KeyFields.Length];

        int i;

        for ( i = 1; i == KeyFields.Length - 1; ++i )

        {

          KeyFieldColumns[ i ] = dt.Columns[ KeyFields[ i ].Trim() ];

        }

        dt.PrimaryKey = KeyFieldColumns;

      }

      return dt;

    }

    #endregion

  }

}

希望本文所述對大家asp.net程序設計有所幫助。

更多信息請查看網絡編程
由于各方面情況的不斷調整與變化,易賢網提供的所有考試信息和咨詢回復僅供參考,敬請考生以權威部門公布的正式信息和咨詢為準!

2026上岸·考公考編培訓報班

  • 報班類型
  • 姓名
  • 手機號
  • 驗證碼
關于我們 | 聯系我們 | 人才招聘 | 網站聲明 | 網站幫助 | 非正式的簡要咨詢 | 簡要咨詢須知 | 新媒體/短視頻平臺 | 手機站點 | 投訴建議
工業和信息化部備案號:滇ICP備2023014141號-1 云南省教育廳備案號:云教ICP備0901021 滇公網安備53010202001879號 人力資源服務許可證:(云)人服證字(2023)第0102001523號
云南網警備案專用圖標
聯系電話:0871-65099533/13759567129 獲取招聘考試信息及咨詢關注公眾號:hfpxwx
咨詢QQ:1093837350(9:00—18:00)版權所有:易賢網
云南網警報警專用圖標
中文字幕免费精品_亚洲视频自拍_亚洲综合国产激情另类一区_色综合咪咪久久
欧美精品aa| 亚洲三级免费| 欧美另类69精品久久久久9999| 亚洲午夜羞羞片| 亚洲欧美日韩视频一区| 久久国产精品99精品国产| 国产精品尤物| 在线观看福利一区| 一区二区精品国产| 欧美区亚洲区| 亚洲福利视频网| 亚洲愉拍自拍另类高清精品| 亚洲一区二区三区在线观看视频 | 欧美韩国日本一区| 欧美国产成人精品| 欧美人成免费网站| 红桃视频成人| 久久亚洲精品一区二区| 黑人操亚洲美女惩罚| 久久亚洲精品一区| 影音国产精品| 国产精品人人爽人人做我的可爱| 99精品欧美一区二区三区| 欧美视频你懂的| 欧美手机在线视频| 狠狠狠色丁香婷婷综合激情| 国产在线观看91精品一区| 亚洲最黄网站| 欧美特黄一区| 在线观看一区二区精品视频| 久久久久久电影| 亚洲亚洲精品在线观看| 欧美午夜宅男影院在线观看| 欧美日韩国产欧| 久久久综合网| 一区二区激情小说| 国产酒店精品激情| 久久视频在线视频| 久久精品水蜜桃av综合天堂| 欧美另类视频| 欧美亚洲自偷自偷| 国产自产精品| 欧美日韩久久精品| 欧美成人情趣视频| 欧美日韩美女一区二区| 欧美1区2区3区| 亚洲一区二区三区视频| 在线看不卡av| 国产精品免费久久久久久| 久久久久久成人| 亚洲片区在线| 午夜精品一区二区三区在线视 | 日韩视频在线免费观看| 在线观看亚洲专区| 99www免费人成精品| 国产精品99久久99久久久二8| 欧美一区二区精品在线| 欧美另类专区| 国产欧美日韩亚洲| 久久青草福利网站| 日韩亚洲欧美中文三级| 国产日韩欧美一区在线| 久久精品亚洲精品国产欧美kt∨| 久久久久国产精品一区二区| 国内自拍一区| 久久精品夜色噜噜亚洲a∨| 国产精品国产一区二区| 亚洲日本中文| 欧美啪啪一区| 亚洲欧美日韩国产一区| 国产视频欧美视频| 免费91麻豆精品国产自产在线观看| 国产欧美一区二区精品仙草咪| 欧美一区二区三区免费观看| 激情伊人五月天久久综合| 欧美精品免费在线| 欧美jizz19hd性欧美| 欧美二区在线播放| 国产精品久久久久久久久果冻传媒| 另类av一区二区| 欧美日韩在线免费观看| 欧美无砖砖区免费| 国产一区二区欧美| 在线观看日韩| 亚洲视频在线观看三级| 午夜国产一区| 久久全球大尺度高清视频| 另类天堂视频在线观看| 欧美成人自拍| 国产视频亚洲精品| 欧美中文在线视频| 亚洲理伦在线| 一卡二卡3卡四卡高清精品视频 | 欧美日韩直播| 久久综合色8888| 久久精品理论片| 亚洲综合日本| 欧美一区二区在线| 亚洲在线观看免费| 99re66热这里只有精品3直播 | 国产精品成人一区二区三区吃奶 | 国产欧美 在线欧美| 欧美国产视频在线观看| 欧美精品在线免费| 久久精品一区四区| 亚洲一区二区在线免费观看视频 | 伊人夜夜躁av伊人久久| 欧美激情网站在线观看| 久久手机精品视频| 久久成人这里只有精品| 午夜在线一区二区| 欧美一区二区在线视频| 欧美亚洲一区| 亚洲综合首页| 午夜精品久久久99热福利| 欧美一区二区视频在线观看2020| 亚洲欧美激情视频| 久久男人av资源网站| 久久精品2019中文字幕| 久久久久久综合| 欧美1区3d| 国产精品视频免费在线观看| 国产伦精品一区二区三| 国内久久精品视频| 亚洲精品国久久99热| 亚洲美女黄网| 欧美一区二区三区精品电影| 久久久亚洲影院你懂的| 欧美日韩视频专区在线播放 | 欧美日韩中文在线| 欧美午夜免费影院| 黄页网站一区| 亚洲影院在线| 欧美视频久久| 亚洲毛片在线观看| 蜜桃av综合| 国产一区高清视频| 精品白丝av| 国产精品进线69影院| 国产欧美亚洲视频| 中国成人在线视频| 久久精品视频免费| 国产欧美日韩综合| 亚洲男女自偷自拍| 欧美日韩精品在线| 日韩视频免费在线| 欧美巨乳波霸| 在线国产日韩| 欧美精品免费播放| 一区二区三区免费网站| 欧美不卡视频一区| 亚洲第一中文字幕| 欧美成人中文字幕在线| 亚洲丰满在线| 欧美日本韩国在线| 日韩亚洲欧美一区二区三区| 欧美日本不卡高清| 中文欧美在线视频| 国产精品久久久久久妇女6080 | 国产视频欧美视频| 久久av在线| 亚洲精品乱码久久久久久| 欧美日本不卡| 久久不射中文字幕| 在线观看日韩| 国产精品国产三级国产普通话蜜臀 | 久久久国产午夜精品| 在线观看欧美亚洲| 国产精品成人在线观看| 久久久www成人免费无遮挡大片 | 亚洲综合日韩中文字幕v在线| 欧美日韩亚洲视频| 亚洲精品色婷婷福利天堂| 欧美精品18+| 国产一区自拍视频| 欧美精品一区在线播放| 中文亚洲欧美| 亚洲激情视频网站| 国产中文一区| 国产精品久久久久久久久久久久久久 | 国产精品成人一区二区艾草| 亚洲一区国产精品| 亚洲美洲欧洲综合国产一区| 国产精品女人毛片| 欧美日韩国产一区| 欧美成人性生活| 欧美高清一区二区| 葵司免费一区二区三区四区五区| 亚洲欧美在线磁力| 亚洲欧美日韩一区二区三区在线| 一本色道久久综合亚洲91| 亚洲精品乱码久久久久久黑人 | 亚洲欧美高清| 亚洲午夜一级| 欧美一区二区三区免费观看| 午夜免费在线观看精品视频| 亚洲欧美不卡| 久久精品理论片| 欧美成人精品激情在线观看| 国产精品久久久亚洲一区 |