INNOBATE.System.Collections.Generic 1.0.1

System.Collections.Generics

Extension methods for System.Collections.Generics

ToDataTable

The provided code is a C# extension method that converts a List<T> to a DataTable. Here's a brief explanation of the code:

• The ToDataTable<T> method creates a new DataTable and sets its name to the name of the type T.
• It then gets all the public instance properties of the type T and adds them as columns to the DataTable.
• For each item in the list, it gets the values of the properties and adds them as a new row to the DataTable.
• The IsNullable method checks if a type is nullable. It returns true if the type is either a reference type or a Nullable value type.
• The GetCoreType method returns the underlying type if the type is nullable, otherwise it returns the type itself.

This extension method can be useful when you need to convert a list of objects to a DataTable for data processing or data binding purposes. For example, you might use it when binding data to a GridView in ASP.NET or when you need to perform operations on the data using ADO.NET.

Please note that this method only considers public instance properties of the type T. Non-public properties, static properties, and fields are not included in the DataTable. If you need to include these members, you would need to modify the method accordingly.

Also, this method does not support complex types or nested types. If the type T contains properties that are complex types or nested types, you would need to handle them separately.

Eaxample

An example of how you can use the ToDataTable<T> method. This example assumes that you have a List<Student> where Student is a class with properties Name and Age.

public class Student
{
    public string Name { get; set; }
    public int Age { get; set; }
}

public class Program
{
    static void Main(string[] args)
    {
        // Create a list of students
        List<Student> students = new List<Student>
        {
            new Student { Name = "John Doe", Age = 20 },
            new Student { Name = "Jane Doe", Age = 22 },
            new Student { Name = "Jim Doe", Age = 24 },
        };

        // Convert the list of students to a DataTable
        DataTable dt = students.ToDataTable();

        // Print the DataTable to the console
        foreach (DataRow row in dt.Rows)
        {
            foreach (DataColumn column in dt.Columns)
            {
                Console.Write($"{row[column]} ");
            }
            Console.WriteLine();
        }
    }
}

In this code, we first create a list of Student objects. We then call the ToDataTable method on this list to convert it into a DataTable. Finally, we print the contents of the DataTable to the console.

This will output:

John Doe 20
Jane Doe 22
Jim Doe 24

Shuffle

A new extension method for IEnumerable<T> called Shuffle. This method uses the random number generator to shuffle a collection, returning a new sequence with the elements in a random order

Example Showing Shuffle extension method in a .NET application

class Program
{
    static void Main()
    {
        var numbers = Enumerable.Range(1, 10).ToList();
        var shuffledNumbers = numbers.OrderByShuffle().ToList();

        Console.WriteLine("Original numbers:");
        foreach (var number in numbers)
        {
            Console.Write(number + " ");
        }

        Console.WriteLine("\nShuffled numbers:");
        foreach (var number in shuffledNumbers)
        {
            Console.Write(number + " ");
        }
    }
}

In this example, we first create a list of numbers from 1 to 10. We then use the OrderByShuffle extension method to shuffle this list. The shuffled list is then printed to the console.