How do I return objects of different types from the same function

Question

3.50/5 (2 votes)

See more:

How do I reuse code in the following functions to return objects of different types?

C#

public A Execute(object parameters)
{
    using (var x = X.Create(parameters))
    {
        Process(x);
        return Func1(x);
    }
}

public B Execute(object parameters)
{
    using (var x = X.Create(parameters))
    {
        Process(x);
        return Func2(x);
    }
}

Func1 and Func2 are two different functions with different return types. I feel like some adaptation of the strategy pattern can be used here but I'm not sure what.

Posted 10-May-15 13:27pm

Sri Prasad Tadimalla

Updated 10-May-15 13:33pm

v2

Add a Solution

Comments

PIEBALDconsult 10-May-15 20:15pm

You can't do that. You need to sit back and think more clearly about what you really want.

BillWoodruff 11-May-15 1:32am

For this idea to work (compile) based on your code example, both Funcs, the Process method, and the Class X and its 'Create method, would have to be static, and the Class X would have to implement IDisposable.

I suggest you add to your question a description of what you are dealing with that requires a Factory class that can return a new 'A or 'B.

There are examples of how to create a Factory Class implementation in C# here on CodeProject, and, of course, on the net.

BillWoodruff 11-May-15 9:17am

I've posted an example of a working FactoryClass; see if that is helpful; if it's not helpful, let me know, and I'll remove it.

2 solutions

Add a Solution

Add your solution here

Treat my content as plain text, not as HTML

Preview 0

…

Existing Members

Sign in to your account

...or Join us

Download, Vote, Comment, Publish.

Your Email
Password
Forgot your password?

Your Email
This email is in use. Do you need your password?
Optional Password

I have read and agree to the Terms of Service and Privacy Policy
Please subscribe me to the CodeProject newsletters

When answering a question please:

Read the question carefully.
Understand that English isn't everyone's first language so be lenient of bad spelling and grammar.
If a question is poorly phrased then either ask for clarification, ignore it, or edit the question and fix the problem. Insults are not welcome.
Don't tell someone to read the manual. Chances are they have and don't get it. Provide an answer or move on to the next question.

Let's work to help developers, not make them feel stupid.

This content, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Sascha Lefèvre · Accepted Answer · 2015-05-10T13:48:00

Solution 1

You can't have methods in the same class that only differ by their return type.

I can think of two ways for code-reuse here, both requiring making Execute(..) a generic method.

1) If you can replace Func1 and Func2 by a generic Func<T> :

C#

public T Execute<T>(object parameters)
{
    using (var x = X.Create(parameters))
    {
        Process(x);
        return Func<T>(x);
    }
}

2) If not, pass Func1 or Func2 as a delegate:

C#

// "..." stands for the static type name of the "x" below:
public T Execute<T>(object parameters, Func<..., T> func) 
{
    using (var x = X.Create(parameters))
    {
        Process(x);
        return func(x);
    }
}

Edit:
If your intention is to create a factory-method that returns either an object of type A or B, depending on the value of parameters, and A and B derive from a common base class (I'll call it A0 here) then something like this would be alright:

C#

public A0 Execute(object parameters)
{
    using (var x = X.Create(parameters))
    {
        Process(x);

        if (parameters == indicate_you_want_A)
            return Func1(x);
        else if (parameters == indicate_you_want_B)
            return Func2(x);
        else
            throw new NotSupportedException("meaningful message here");
    }
}

Posted 10-May-15 13:48pm

Sascha Lefèvre

Updated 11-May-15 0:36am

v3

Comments

Sergey Alexandrovich Kryukov 10-May-15 21:07pm

Sure, a 5.
—SA

Sascha Lefèvre 11-May-15 7:29am

Thank you, Sergey.

BillWoodruff 11-May-15 1:34am

This is good medicine, Sascha, but I suspect the OP here has a more serious problem. See my comment on the OP.

Sascha Lefèvre 11-May-15 6:37am

Good idea, Bill, I added it to the solution. Thank you.

Sri Prasad Tadimalla 11-May-15 3:25am

Thanks everyone. I thought of passing the function in but I usually try to avoid doing that. The generic approach also seems like a good idea, especially if I make T an interface.

Sascha Lefèvre 11-May-15 6:39am

Thank you for accepting my answer :)
It might or might not be what you want, but I added a new part to my answer, based on BillWoodruff's comment, please take a look.

BillWoodruff 11-May-15 8:54am

Hi Sascha, I'm going to post an example of working code that will generate new Classes where the Type constraint is Struct. I'm guessing that the business with Func in the OP's question calls for a certain technique, and I'll be curious to see if am correct. I'd be delighted to have your feedback !

Sascha Lefèvre 14-May-15 9:30am

Bill, I gave you feedback to the best of my abilites. I'm not sure in every aspect of it and I would be happy to hear your thoughts on it :)

Maciej Los 11-May-15 17:23pm

+5!

Sascha Lefèvre 11-May-15 17:31pm

Thank you, Maciej :)

Sri Prasad Tadimalla 11-May-15 20:28pm

In the end, this is what I came up with.

<pre lang="c#">public void ExecuteOnReader(string query, Action<idatareader> dataReaderAction)
{
using (OdbcConnection connection = new OdbcConnection(_connectionString))
{
try
{
connection.Open();
Logger.LogInfo("Connection Opened");
}
catch (Exception ex)
{
Logger.LogException(ex, "Executing Query", "Unable to connect to database with: " + _connectionString);
throw;
}
SetDateFormatForOracleDatabases(connection);
Logger.LogSql(query, "Query");
try
{
var w = Logger.StartWatch();
using (var command = new OdbcCommand(query, connection))
{
using (var reader = command.ExecuteReader(CommandBehavior.KeyInfo))
dataReaderAction.Invoke(reader);
}
Logger.StopWatch(w, "Query Execution");
}
catch (Exception ex)
{
Logger.LogException(ex, "Executing Query", "Unable to execute query: " + query);
throw;
}
}
}
</pre>

BillWoodruff · Accepted Answer · 2015-05-11T03:16:00

Here's an example of a static generic Class that will return instances of new Classes where the internal data type used by the new Class is constrained to be a struct. I believe this example demonstrates the "usual" features of implementing the Factory Class pattern in C#: use of an interface; generic constraints, etc.

C#

using System;

namespace StructClassFactoryDemo
{
    // see Note #1
    internal interface IGenericStruct<T> where T : struct
    {
        T[] Parameters { set; get; }

        void Execute(Func<T,T> paramFunc, T[] parameters);
    }

    internal static class GenericStructFactory<T> where T : struct
    {
        internal static GenericStructClass<T> Create(Func<T,T> paramFunc, params T[] parameters)
        {
            GenericStructClass<T> newT = new GenericStructClass<T>();

            if (paramFunc != null) newT.Execute(paramFunc, parameters);

            Console.WriteLine("created {0} type",  typeof(T).Name);

            return newT;
        }
    }

    public class GenericStructClass<T> : IGenericStruct<T> where T : struct
    {
        public T[] Parameters { set; get; }

        public void Execute(Func<T,T> paramFunc, T[] parameters)
        {
            if (parameters == null) return;

            // see Note #2
            if (typeof(T).IsValueType && paramFunc != null)
            {
                for (int i = 0; i < parameters.Length; i++)
                {
                    parameters[i] = paramFunc(parameters[i]);
                }
            }

            Parameters = parameters;
        }
    }
}

Here's how you might use this Factory in some Class:

C#

// predefined integer function
Func<int,int> intFunc = (x) =>
{
    return x + 100;
};

// predefined double function
Func<double, double> doubleFunc = (x) =>
{
    return x + 43.024;
};

// function parameter defined as 'null
GenericStructClass<int> ClassA0 = GenericStructFactory<int>
    .Create(
    null,
    new int[] { 1, 2, 3, 4, 5, 6 });

// using predefined integer function
GenericStructClass<int> ClassA1 = GenericStructFactory<int>
    .Create(
    intFunc,
    new int[] { 1, 2, 3, 4, 5, 6 });

// using predefined double function
GenericStructClass<double> ClassA2 = GenericStructFactory<double>
    .Create(
    doubleFunc,
    new double[] { 1.24, 2.23, 3.5, 4.9, 5.1, 6.2 });

// using an in-line lambda expression that returns a 'long for the function
GenericStructClass<long> ClassA3 = GenericStructFactory<long>
    .Create(
    x => x + 23,
    new long[] { 1, 2, 3, 4, 5, 6 });

// using an in-line lambda expression that returns a 'DateTime for the function
GenericStructClass<DateTime> ClassA4 = GenericStructFactory<DateTime>
    .Create(
    dt => dt.AddDays(100),
    new DateTime[]
    {
        DateTime.Now, DateTime.Now.AddDays(1), DateTime.Now.AddDays(2)
    });

Notes:

1. even though an Interface is implemented here, the code shown really does not demonstrate its use in a specific way; so, why's it there ? : imho, it is often the case that you will want to extend a Factory class, and you would use the Interface shown to define another Class that would be used as an alternative to 'GenericStructClass. Further, imho, it is a good idea to use Interfaces to "enforce discipline" in development.

2. Note that you can't use 'ValueType as a constraint in a Generic Class, but you can use 'Struct, and, within a Generic Class, you can test to see if the Generic Type is a 'ValueType, as shown here.