Windows formulaire liste d'application à ADO.NET datable

Question

Ceci est ma première question, s'il vous plaît ignorer mes erreurs. Je cours un projet C# qui passe les conditions du flux Twitter, 5 attributs dans une chaîne nommée "urlAll". Je vais diviser les propriétés avec * # 06 # que j'ai déclaré avant qui est donné ci-dessous. J'ai créé un autre projet avec application de formulaire Windows en utilisant LinqToTwitter et il retourne une liste. Tout ce dont j'ai besoin est de retourner la liste comme une table ado.net que j'ai écrite auparavant. Voici mon code de flux Twitter.

//initializing a list of current news feeds 
    private List<Status> currentTweets; 

    //parent class of the form application 
    //interface 
    public TwitterFeed() 
    { 
     //initializing the components 
     InitializeComponent(); 
     //call the function that will display current 200 feeds from twitter 
     GetMostRecent200HomeTimeLine(); 
     //clearing the textbox in which the feeds will be displayed 
     lstTweetList.Items.Clear(); 

     //displaying the feed in text box right 
     currentTweets.ForEach(tweet => lstTweetList.Items.Add(tweet.User.Name + ":" + tweet.Text)); 
     //display follow list in text box left 
     //GetSideBarList(GetFollowers()).ForEach(name => lstFollowNames.Items.Add(name)); 

    } 


    //method that gets current 200 feeds form twitter of the user 
    private void GetMostRecent200HomeTimeLine() 
    { 
     var twitterContext = new TwitterContext(authorizer); 
     var tweets = from tweet in twitterContext.Status 
        where tweet.Type == StatusType.Home && 
        tweet.Count == 200 
        select tweet; 
     currentTweets = tweets.ToList(); 
    } 

quel serait le moyen de les intégrer?

Answer 1

Cela devrait fonctionner si votre liste n'a pas d'autre collection:

public static DataTable ToDataTable<T>(this IList<T> list) 
     { 
     DataTable table = null; 
     if (list != null && list.Count > 0) 
     { 
      PropertyDescriptorCollection properties = TypeDescriptor.GetProperties(typeof(T)); 

      List<PropertyDescriptor[]> propList = new List<PropertyDescriptor[]>(); 

      table = new DataTable(); 
      foreach (PropertyDescriptor item in properties) 
      { 
       if (IsArrayOrCollection(item.PropertyType)) 
       { 
        continue; 
       } 
       AddColumnsForProperties(typeof(T).Namespace, null, table, (new[] { item }).ToList(), ref propList); 
      } 

      object[] values = new object[propList.Count]; 

      foreach (T item in list) 
      { 
       for (int i = 0; i < values.Length; i++) 
        values[i] = GetValueFromProps(propList[i], item) ?? DBNull.Value; 

       table.Rows.Add(values); 
      } 
     } 
     return table; 
     } 

    private static object GetValueFromProps(PropertyDescriptor[] descriptors, object item) 
    { 
    var result = item; 
    foreach (var descriptor in descriptors) 
    { 
     if (result != null) 
     { 
      result = descriptor.GetValue(result); 
     } 
    } 
    return result; 
    } 


    private static void AddColumnsForProperties(string myNamespace, string parentName, DataTable dt, List<PropertyDescriptor> p, ref List<PropertyDescriptor[]> properties) 
    { 
    var pLast = p.Last(); 

    if (pLast.PropertyType.Namespace != null && pLast.PropertyType.Namespace.StartsWith(myNamespace)) 
    { 
     var allProperties = pLast.GetChildProperties(); 
     if (allProperties.Count > 0) 
     { 
      foreach (PropertyDescriptor item in allProperties) 
      { 
       var newP = p.ToList(); 
       newP.Add(item); 

       string childParentName = !String.IsNullOrEmpty(parentName) 
       ? String.Format("{0}.{1}.{2}", parentName, pLast.Name, item.Name) 
       : String.Format("{0}.{1}", pLast.Name, item.Name); 
       if (item.PropertyType.Namespace != null && item.PropertyType.Namespace.ToLower().StartsWith(myNamespace)) 
       { 
       AddColumnsForProperties(myNamespace, childParentName, dt, newP, ref properties); 
       } 
       else if (!dt.Columns.Contains(childParentName)) 
       { 
       dt.Columns.Add(childParentName, Nullable.GetUnderlyingType(item.PropertyType) ?? item.PropertyType); 
       properties.Add(newP.ToArray()); 
       } 
      } 
     } 
     else if (!dt.Columns.Contains(pLast.Name)) 
     { 
      dt.Columns.Add(pLast.Name, Nullable.GetUnderlyingType(pLast.PropertyType) ?? pLast.PropertyType); 
      properties.Add(p.ToArray()); 
     } 
    } 
    else if (!dt.Columns.Contains(pLast.Name)) 
    { 
     dt.Columns.Add(pLast.Name, Nullable.GetUnderlyingType(pLast.PropertyType) ?? pLast.PropertyType); 
     properties.Add(p.ToArray()); 
    } 
    }