Define class type to calling a generic method

Question

0.00/5 (No votes)

See more:

I have an interface called IAuditable as follows:

C#

public interface IAuditable
{
    string AuditSummary
    {
        get;
    }
    string AuditDetails
    {
        get;
    } 
}

And two generic method in AuditTrail class as follows:

C#

public T GetActualOldValue<T>() where T : IAuditable
    {
        return FromXElement<T>(OldValue);
    }
    public T GetActualNewValue<T>() where T : IAuditable
    {
        return FromXElement<T>(NewValue);
    }

as well as i have one property to returning Audit Summary by getting a class at run time as follows:

C#

public string AuditSummary
    {
        get
        {
            if (HasNewValue || HasOldValue)
            {
                string libraryVal = GetLibraryValue();
                Assembly assembly = Assembly.Load(libraryVal);
                foreach (Type type in assembly.GetTypes())
                {
                    if (type.IsClass == true)
                    {
                        if (type.FullName.EndsWith("." + ClassName))
                        {
                            /*Here i want to call GetActualNewValue<foundClass>().AuditSummary
                             * or GetActualOldValue<foundClass>().AuditSummary;
                             */
                        }
                   }
                }
            }
            return "";
        }
    }

As you know we can find class at run time in specific library, Please note i don't want to call a generic method at run time,just wanna call generic method with founded, in other words how can i pass a specific class to GetActualNewValue<...>() as T,

C#

AuditTrail auditTrail = AuditTrail.GetAuditTrail(76);
string summmary = auditTrail.GetActualOldValue<DTClient>().AuditSummary;
string details = auditTrail.GetActualOldValue<DTClient>().AuditDetails;

This code work perfectly but the main problem is DTClient must find at run time and define as T for GetActualValue.

Thanks all.

Posted 11-Aug-13 23:31pm

ARIA 5

Add a Solution

1 solution

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)

Sergey Alexandrovich Kryukov · Answer 1 · 2013-08-12T06:46:00

It's not clear where do you want to find the type to be used in the generic, from what set of types. It's even less clear if such approach is reasonable or not. By some reasons, I doubt it.

However, the problem itself is technically simple. The only problems are: 1) what happens if you find more then one class? 2) where do you want to get the instance of the class? instantiate it?

However, let's assume that you already have some set of types, you stop search if you find the first of types which satisfy the criterion, and you want to instantiate the type when you find it, it would be pretty simple. Let's also assume you have some assembly where you want to find all the types it declares and return the instance of the first suitable type found. We will also need one more assumption: the type implementing IAuditable should have some certain signature. In my example, it will be the parameterless constructor (most usual case):

C#

using System;
using System.Reflection;

//...

static IAuditable FindFirstAuditable(Assembly assembly) {
    Type[] types = assembly.GetTypes();
    string interfaceName = typeof(IAuditable).FullName;
    foreach (Type type in types) {
        Type interfaceType = type.GetInterface(interfaceName, false);
        if (interfaceType == null) continue;
        ConstructorInfo constructor = type.GetConstructor(Type.EmptyTypes); // a constructor without parameters
        if (constructor == null) continue;
        return (IAuditable)constructor.Invoke(null); // the cast it safe,
                                                     // because we already tested that the interface is implemented
    } //loop
    return null;
}

If you want just the type, you can return the type instead, of you can call GetType() on the object you have.

As you can see, too many assumptions. Also, it could be slow. But this is because your goals are not clear enough. I hope it will be enough for you to understand what techniques you could use and do it in your way. And I would recommend you to seriously review your approach.

—SA