CODEWITHSUNDEEP
c#asp.net-mvcgenerics
user5375600
user5375600

Reputation:

Trying to Utilise a generic <T> collection

I am using C# and I thought I finally had the chance to understand a Generic type. I have several strongly typed objects that need the same static method. Rather than create one static method for each type I thought I could make it generic. Something I have never done and really wanted too.

Here is where I invoke it.

   bool isDuplicate = Utilities.GetDuplicates<RoomBookingModel>(roomBookings);

Here is my static method which resides in a static class called Utilities.

 public static bool GetDuplicates<T>(List<T> pBookings)
    {           
        foreach (var item in pBookings)
        {
            var myVal = item.bookingId
        }
        return true;
    }

So I want to get at the values within var item inside the foreach loop so I can do comparisons. It's definately passed pBookings because I can hover and they have a .Count() with a collection of my strongly typed object. I am missing something here, possibly a casting process. I was wondering if anyone could advise me where I am coming up short.

var myVal = item.bookingId - I cannot get the bookingID from item because I am lacking in some basic understanding here. bookingId doesn't exist, I just get access to extension methods such as .toString and .equals

ANSWER OF SORTS What I did based on all of your really helpful assistance. I utilised Anderson Pimentel. I'm probably still off the mark but wanted to garner anyones thoughts here.

So basically I have several booking models, all need checking for duplicates. I really wanted to understand Generics in this way. So what I did is. Created a base class.

public class BookingBaseModel
{
    public int BookingID { get; set; }
    public DateTime BookingStartDateTime { get; set; }
    public DateTime BookingEndDateTime { get; set; }
}

Then had my booking classes all inherit whats common to all. Like this...

public class RoomBookingModel : BookingBaseModel
{
    public string RoomName{ get; set; }
}

public class vehicleBookingModel : BookingBaseModel
{
    public string vehicleName{ get; set; }
}

Then in my utilities static helper I did this..

 public static void GetDuplicates<T>(List<T> items) where T : BookingBaseModel
    {
        foreach (var item in items)
        {
            int myId = item.ID;
            DateTime startDateTime = item.BookingStartDateTime;
            DateTime endDateTime = item.BookingEndDateTime;

            //Do you logic here
        }
    }

Then finally did something like this in corresponding controller action.

RoomController...

        Utilities.GetDuplicates<RoomBookingModel>(roomBookings);

VehicleController....

        Utilities.GetDuplicates<VehicleBookingModel>(vehicleBookings);

Is this basically how we go about using generics in this way?

Upvotes: 1

Views: 120

Answers (7)

spender
spender

Reputation: 120480

I wonder if generics is really the tool for the job here. Your needs would be better served if each of your strongly typed objects shared a common interface.

"I have several strongly typed objects that need the same static method."

In this situation, all of the classes must share a common feature, such as, for instance, a property BookingId.

So, you'd need to formalize this by extracting this common interface:

public interface IBooking
{
    int BookingId{ get; }
}

Make sure that every one of your strongly typed items implements the interface:

public class RoomBooking : IBooking
{
    //etc...
}

And now make your static method accept IBooking instances:

public static bool GetDuplicates(IEnumerable<IBooking> pBookings)
{
    //does pBookings contain items with duplicate BookingId values?
    return pBookings.GroupBy(b => b.BookingId).Any(g => g.Count() > 1);
}

An easy read that isn't obfuscated by the unnecessary use of generics.

Upvotes: 1

Oliver
Oliver

Reputation: 45111

If you like to use a generic method, you have to provide also a generic method, which is able to generate a key out of the specified type T. Luckily we have LINQ which already provides the needed parts to build your generic method:

internal class Extensions
{
    public static IEnumerable<T> GetDuplicates<T, TKey>(this IEnumerable<T> source, Func<T, TKey> keySelector)
    {
        return source.GroupBy(keySelector)
                     .Where(group => group.Skip(1).Any())
                     .SelectMany(group => group);
    }

    public static bool ContainsDuplicates<T, TKey>(this IEnumerable<T> source, Func<T, TKey> keySelector)
    {
        return GetDuplicates(source, keySelector).Any();
    }
}

By having this (and type inference) you can use these methods e.g. by calling:

var hasDuplicates = roomBookings.ContainsDuplicates(item => item.bookingId);

if(hasDuplicates)
{
    Console.WriteLine("Duplicates found:");

    foreach (var duplicate in roomBookings.GetDuplicates(item => item.bookingId))
    {
        Console.WriteLine(duplicate);
    }
}

Upvotes: 1

Jes&#250;s L&#243;pez
Jes&#250;s L&#243;pez

Reputation: 9221

Perhaps you are looking for something like this:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Duplicates
{

    public static class EnumerableExtensions
    {
        public static bool HasDuplicates<T, I>(this IEnumerable<T> enumerable, Func<T, I> identityGetter, IEqualityComparer<I> comparer )
        {
            var hashSet = new HashSet<I>(comparer);
            foreach (var item in enumerable)
            {
                var identity = identityGetter(item);
                if (hashSet.Contains(identity)) return true;
                hashSet.Add(identity);
            }
            return false;
        }

        public static bool HasDuplicates<T, I>(this IEnumerable<T> enumerable, Func<T, I> identityGetter)
        {
            return enumerable.HasDuplicates(identityGetter, EqualityComparer<I>.Default);
        }
    }

    public class Booking
    {
        public int BookingId { get; set; }
        public string BookingName { get; set; }
    }

    public class Customer
    {
        public string CustomerId { get; set; }
        public string Name { get; set; }
    }


    class Program
    {
        static void Main(string[] args)
        {
            var bookings = new List<Booking>()
            {
                new Booking { BookingId = 1, BookingName = "Booking 1" },
                new Booking { BookingId = 1, BookingName = "Booking 1" }
            };

            Console.WriteLine("Q: There are duplicate bookings?. A: {0}", bookings.HasDuplicates(x => x.BookingId));

            var customers = new List<Customer>()
            {
                new Customer { CustomerId = "ALFKI", Name = "Alfred Kiss" },
                new Customer { CustomerId = "ANATR", Name = "Ana Trorroja" }
            };

            Console.WriteLine("Q: There are duplicate customers?. A: {0} ", customers.HasDuplicates(x => x.CustomerId));

        }
    }
}

Upvotes: 0

xanatos
xanatos

Reputation: 111870

As written by others, you don't know anything of T. A classical solution, used by LINQ (see for example GroupBy) is to have your method receive a delegate that does the key-extraction, like:

public static bool GetDuplicates<T, TKey>(List<T> pBookings, Func<T, TKey> selector) 
{
    foreach (var item in pBookings) 
    {
        TKey key = selector(item);
    }

    return true;
}

You then use it like:

GetDuplicates(pBookings, p => p.bookingId);

Upvotes: 1

Kit
Kit

Reputation: 21709

Since there are no constraints or hints about what T is, the compiler does not have enough information. Consider

bool isDuplicate = Utilities.GetDuplicates<int>(roomBookings);

Clearly an int does not have a bookingId member.

Every possible specific type for T would have to have a common base class or interface that has a bookingId, and even then you would have to add a generic constraint to your method signature to access that.

Upvotes: 0

goric
goric

Reputation: 11885

Once you're inside your GetDuplicates method, you have lost all knowledge of the RoomBookingModel type. That's the point of generic methods - they should be able to act on whatever type has been passed in to them, e.g. the logic within them should be generic across any type.

So your foreach loop is fine - you know you've been given a list of something, and you know lists can be iterated. But inside that foreach, item is just a T. You don't know what actual type it is because any type could have been passed in. So it doesn't make sense to access a specific property or method off of item - for example, what if I called GetDuplicates passing in a List<int>? It wouldn't have a bookingId property.

Upvotes: 1

Anderson Pimentel
Anderson Pimentel

Reputation: 5767

The compiler has no hint of what type is T. If you have a base class (or an Interface) which has the bookingId attribute, like BaseModel, you can constrain the generic type like the following:

public class BaseModel
{
    public int Id { get; set; }
}

public static bool GetDuplicates<T>(List<T> items) where T : BaseModel
{           
    foreach (var item in items)
    {
        var myId = item.Id;
        //Do you logic here
    }
    return true;
}

Upvotes: 1

Related Questions