Is it possible to make a template method that operates on a struct that has some known attributes

Question

I have to structs both having e.g. "Id":

public struct User
{
    public int Id;
    public string Email;
}
public struct Computer
{
    public int Id;
    public string Name;
}

I'd like to make a template method to rewrite Id from one IList of Computers, Users and such to another.

I've tried below, but VS complains T does not contain a definition for Id:

    private static void RewriteIListIds<T>(ref IList<T> pre, IList<T> post)
    {
        if (post != null && post.Count > 0)
        {
            Assert.IsTrue(pre != null && pre.Count > 0);
            for (int i = 0; i < post.Count; i++)
            {
                T preElement = pre[i];
                T postElement = post[i];
                preElement.Id = postElement.Id;
                pre[i] = preElement;
            }
        }
    }

EDIT: Interesting ideas but I probably should have mention I'm testing a service which I really don't want and most probably can't really change.

EDIT2: Just for future references and to be more clear - I've probably made this problem more generic than it should be - User and Computer structs are what a Web Service (currently configured as SOAP) returns in an IList. [DataContract] and [Data Member] was removed from above example to make this problem a bit more generic.

Answer 1

No. C# generics aren't C++ templates, basically. I would suggest that:

• You stop exposing fields publicly
• You stop using mutable structs
• You stop using ref when you don't need to (see my article on parameter passing for more details)
• You extract an interface with a read/write Id property
• You implement that interface on two classes for User and Computer
• You add a constraint of where T : IFoo to your generic method where IFoo is your new interface (with a better name, of course)
• You can then remove the pre[i] = preElement; line of your method too...

Meta: Don't refer to a field as an attribute; the word attribute has a very specific meaning in .NET which is not the same as a field or property.

(Apologies for the slightly curt response - I don't have time to explain each point in detail right now.)

Answer 2

I agree with Jon: you probably don't have to do this, and it can be done in some other way. But if you really have to you can tell the method how the type gets or sets its id.

  public delegate int IdGetter<in T>(T holder);
  public delegate T IdSetter<T>(T holder, int newId);

  private static void RewriteIListIds<T>(IList<T> pre, IList<T> post, 
                                         IdGetter<T> getId, IdSetter<T> setId)
  {
     if (post != null && post.Count > 0)
     {
        for (int i = 0; i < post.Count; i++)
        {
           T preElement = pre[i];
           T postElement = post[i];
           int id = getId(preElement);
           postElement = setId(postElement, id);
           post[i] = postElement;
        }
     }
  }

To use it

RewriteIListIds<User>(aList, bList, u => u.Id, (u,id) => {u.Id = id; return u;});

Answer 3

I assume that you have a C++ background? The C# feature you are using is called "generics".

Generics are not templates.

[...] You can think of templates as a fancy-pants search-and-replace mechanism. When you say DoIt<string> in a template, the compiler conceptually searches out all uses of “T”, replaces them with “string”, and then compiles the resulting source code. Overload resolution proceeds with the substituted type arguments known, and the generated code then reflects the results of that overload resolution.

[...] That’s not how generic types work; generic types are, well, generic. We do the overload resolution once and bake in the result. We do not change it at runtime when someone, possibly in an entirely different assembly, uses string as a type argument to the method

On another note, it is strongly recommended not to create mutable structs in C#.

Answer 4

You need to constrain you generic so that the compiler knows something about type T. One way to do this is to create a parent object that contains the Id value, lets call it Thing, then have your two objects inherit from that. Then you can declare your generic so that T is constrained to children of Thing:

public class Thing
{
    public int Id;
}

public class User: Thing
{
    public string Email; 
}

public class Computer : Thing 
{    
    public string Name; 
} 

private static void RewriteIListIds<T>(ref IList<T> pre, IList<T> post) where T: Thing

Now the compiler knows that T must contain all the properties of Thing so it can assume there will be an Id field. If you don't want to use inheritance, the you can do the same thing with an interface and have each of your objects implelment that interface.