[RESOLVED] sub returning diffrent types

[Crash893]

Hey all.

I two subs that are almost exactly identical that return two different types of control


I would use the sub something like

textbox1.text = stringtoMatchtype1("match1").chatter;

where chatter is a property of matchtype1(and 2)

I could just return a control but then i couldnt access the propertys and methods of that contorl.



any ideas to point me down a better path?

private MatchType1 StringToMatchType1(string name)
        {
            foreach (TabPage tp in tabControl1.Controls)
            {
                foreach (Control c in tp.Controls)
                {
                    if (c is MatchType1)
                    {
                        if (c.Name == name)
                        {
                            return (MatchType1)c;
                        }
                    }
                }
            }
            throw new Exception("Matchtype1 not found" + name);
        }
        private MatchType2 StringToMatchType2(string name)
        {
            foreach (TabPage tp in tabControl1.Controls)
            {
                foreach (Control c in tp.Controls)
                {
                    if (c is MatchType2)
                    {
                        if (c.Name == name)
                        {
                            return (MatchType2)c;
                        }
                    }
                }
            }
            throw new Exception("Matchtype2 not found" + name);
        }

[wy125]

you could just make one method that returns the Control as it is and then cast it since you already know what the type is.

[Crash893]

i could but it seems like a lot extra repeat code

[wy125]

i was proposing using one method and just searching by name. You could also use a generic method if you are using .net 3.5

private T FindControl<T>(string name)
        {
            foreach (Control c in this.Controls)
            {
                if (c.Name == name && c is T)
                {
                    Type retType = typeof(T);
 
                    return (T)Convert.ChangeType(c, retType);
 
                    
                }
 
            }
 
            return default(T);
        }

then if you're looking for a button do the following:

Button b = FindControl<Button>("YourButtonName");

You could also change this to a nongeneric method and return an object. Then cast appropriately. I don't think it's possible anyway to have a control of the same name so you shouldn't have trouble.

[high6]

You could make MatchType an interface and then have MatchType1/MatchType2 inherit from it.

[jmcilhinney]

There's no such thing as a "sub" in C#. That's a VB thing. In VB a Sub is a method that doesn't return a value and a Function is a method that does return a value. In C# all methods are functions. The C# equivalent of a VB Sub is a void function. That said, both your functions DO return something so they wouldn't be Subs in VB even.

wy25 has the right of it, except that this is neater:

private T FindControl<T>(string name) where T:Control
{
    foreach (Control ctl in this.Controls)
    {
        if (ctl is T && ctl.Name == name)
        {
            return (T)ctl;
        }
    }
 
    return null;
}

You constrain T to inherit Control and then the compiler allows you to cast as T inside the method. You can also return null explicitly instead of using default because you know that any type that inherits Control must be a reference type.

[Crash893]

how is that any diffrent than just returning the type of control.

i would still have to cast it as the type im expecting but now i just would do it where it was called rather than in the method itself


i'm trying to avoid this because it leaves little nuggets of repeat code all over the place.

[techgnome]

what? You wouldn't need to cast it... it would already be done as part of <T> .... you specify the type you are looking for on the way in.... the object that comes out (if not NULL) will be of that type.

And what "nuggets of repeat code" are you going on about?

-tg

[syntaxeater]

This work for you?

        private MatchType1 FindControl(string value) 
        {
            return this.Controls.OfType<MatchType1>().Where(c => c.chatter == value).FirstOrDefault();
        }

[jmcilhinney]

This work for you?

        private MatchType1 FindControl(string value) 
        {
            return this.Controls.OfType<MatchType1>().Where(c => c.chatter == value).FirstOrDefault();
        }

That's a a nice use of LINQ that leads to some concise code. To combine the generic method suggested by by wy125, the constraint suggested by myself and the LINQ suggested by syntaxeater:

public T FindControl<T>(string name) where T : Control
{
    return this.Controls.OfType<T>().Where(c => c.Name == name).FirstOrDefault();
}

Now you can use that method to return a control of any specific type with a specific name.

As tg said, the whole point of generics is to be able to use the same code for many different types. This method returns a reference of type T where YOU specify what T is when you call the method. If you call the method like this:

this.FindControl<MatchType1>("something");

then the method will return a reference of type MatchType1. If you call it like this:

this.FindControl<MatchType2>("something");

then it will return a reference of type MatchType2. If you call it like this:

this.FindControl<Button>("something");

then it will return a reference of type Button.

If you use a List<T> do you have to cast the items as you get them? Of course not. You specify what T is when you create the List and then every item you get from the List is that type. There's no need to cast. Generic methods are the same. You fix T when you call the method and then every use of T in the method becomes that type. In this case the return type of the method is T, so if you fix T to be Button then the return type of the method becomes Button. Etc.

[wy125]

that's pretty cool guys. I've learned something new...

[jmcilhinney]

I should actually point out an error in my earlier terminology that many people make. The code that syntaxeater provided earlier and I modified doesn't actually use LINQ per se. It uses extension methods and lambda expressions directly. They are both language features that were added to support LINQ but their use is not limited to LINQ exclusively. There's no actual LINQ query in that code so it's not actually LINQ. It's still pretty cool code, but an actual LINQ implementation would have to contain an actual query, with a 'where' clause rather than a call to the Where method. Of course, such a query would be implemented in much the same way as the code provided.

[jmcilhinney]

Here's the equivalent using an actual LINQ query:

public T FindControl<T>(string name) where T : Control
{
    return (from t in this.Controls.OfType<T>()
            where t.Name == name
            select t).FirstOrDefault();
 
}

As far as I'm aware the OfType and FirstOrDefault calls can't be folded into the query syntax in any way.

[Crash893]

I should actually point out an error in my earlier terminology that many people make. The code that syntaxeater provided earlier and I modified doesn't actually use LINQ per se. It uses extension methods and lambda expressions directly. They are both language features that were added to support LINQ but their use is not limited to LINQ exclusively. There's no actual LINQ query in that code so it's not actually LINQ. It's still pretty cool code, but an actual LINQ implementation would have to contain an actual query, with a 'where' clause rather than a call to the Where method. Of course, such a query would be implemented in much the same way as the code provided.

i see now

I will try this out and let you know

Thanks

[syntaxeater]

Here's the equivalent using an actual LINQ query:

public T FindControl<T>(string name) where T : Control
{
    return (from t in this.Controls.OfType<T>()
            where t.Name == name
            select t).FirstOrDefault();
 
}

As far as I'm aware the OfType and FirstOrDefault calls can't be folded into the query syntax in any way.

OfType - There is a way, but not one more concise than what has been previously suggested:

        public T FindControl<T>(string name) where T : Control
        {
            return (T)(from Control t in this.Controls
                       where t.GetType() == typeof(T) && t.Name == name
                       select t).FirstOrDefault();
        }

However, using Extension OfType is by far a nicer means (in my opinion).

FirstOrDefault - no, you can't. The query will not execute until one of the Linq.Enumerable members that produces a result has been called. As far as I am aware, there's no way for it to change the return type based on an anticipated number of results from the expression alone.

[jmcilhinney]

OfType - There is a way, but not one more concise than what has been previously suggested:

        public T FindControl<T>(string name) where T : Control
        {
            return (T)(from Control t in this.Controls
                       where t.GetType() == typeof(T) && t.Name == name
                       select t).FirstOrDefault();
        }

However, using Extension OfType is by far a nicer means (in my opinion).

FirstOrDefault - no, you can't. The query will not execute until one of the Linq.Enumerable members that produces a result has been called. As far as I am aware, there's no way for it to change the return type based on an anticipated number of results from the expression alone.

I was thinking of a specifically LINQ way to replace the OfType call, which there isn't. Certainly there's nothing wrong with testing the type in the 'where' clause but it does then require casting the result before returning, as you've done. If I was going to test the type in the 'where' clause I'd do it with the 'is' operator:

public T FindControl<T>(string name) where T : Control
{
    return (T)(from Control t in this.Controls
               where t is T && t.Name == name
               select t).FirstOrDefault();
}