Сasting a variable to a type without switch case

.everyoneloves__top-leaderboard:empty,.everyoneloves__mid-leaderboard:empty,.everyoneloves__bot-mid-leaderboard:empty{ height:90px;width:728px;box-sizing:border-box;
}

I have a list of objects ListOfObjects that are all of the same type, but the specific type is not known (however, I do know all the possible types). There are
many possible types. Each object has the property Name, which is a string of its type. I want do something like the following:

foreach (object elements in ListOfObjects)

{

    // Some code here that casts elements into the specific type and pass it into another function

}

I know one way to do this is to use a switch case statement

  switch (ListOfObjects[0].Name)

  {

      case "Type1":

          //cast into Type1 and pass into function

      case "Type2":

          //cast into Type2 and pass into function

      default:

          //something

          break;

  }

Is there a cleaner way to do this? Is is possible to store the possible Types in a dictionary and cast from that dictionary?

edited Jan 3 at 2:22

abatishchev

70.4k70267397

asked Jan 3 at 1:39

Twistingcashews

554

3

Maybe not an exact duplicate, but the same concept: Is there a better alternative than this to 'switch on type'? Some of the recent(ly-updated) answers discuss switching on a Type.

– BACON
Jan 3 at 1:49

You might also be interested in C# 8.0 switch expressions (as opposed to statements).

– Theraot
Jan 3 at 2:04

See stackoverflow.com/a/299001/41956. Would it work for you?

– abatishchev
Jan 3 at 2:22

Why you don't want to declare an abstract method which is called here and redefined by each subtype?

– dyukha
Jan 3 at 2:26

add a comment |

foreach (object elements in ListOfObjects)

{

    // Some code here that casts elements into the specific type and pass it into another function

}

I know one way to do this is to use a switch case statement

  switch (ListOfObjects[0].Name)

  {

      case "Type1":

          //cast into Type1 and pass into function

      case "Type2":

          //cast into Type2 and pass into function

      default:

          //something

          break;

  }

Is there a cleaner way to do this? Is is possible to store the possible Types in a dictionary and cast from that dictionary?

edited Jan 3 at 2:22

abatishchev

70.4k70267397

asked Jan 3 at 1:39

Twistingcashews

554

3

Maybe not an exact duplicate, but the same concept: Is there a better alternative than this to 'switch on type'? Some of the recent(ly-updated) answers discuss switching on a Type.

– BACON
Jan 3 at 1:49

You might also be interested in C# 8.0 switch expressions (as opposed to statements).

– Theraot
Jan 3 at 2:04

See stackoverflow.com/a/299001/41956. Would it work for you?

– abatishchev
Jan 3 at 2:22

Why you don't want to declare an abstract method which is called here and redefined by each subtype?

– dyukha
Jan 3 at 2:26

add a comment |

foreach (object elements in ListOfObjects)

{

    // Some code here that casts elements into the specific type and pass it into another function

}

I know one way to do this is to use a switch case statement

  switch (ListOfObjects[0].Name)

  {

      case "Type1":

          //cast into Type1 and pass into function

      case "Type2":

          //cast into Type2 and pass into function

      default:

          //something

          break;

  }

Is there a cleaner way to do this? Is is possible to store the possible Types in a dictionary and cast from that dictionary?

edited Jan 3 at 2:22

abatishchev

70.4k70267397

asked Jan 3 at 1:39

Twistingcashews

554

foreach (object elements in ListOfObjects)

{

    // Some code here that casts elements into the specific type and pass it into another function

}

I know one way to do this is to use a switch case statement

  switch (ListOfObjects[0].Name)

  {

      case "Type1":

          //cast into Type1 and pass into function

      case "Type2":

          //cast into Type2 and pass into function

      default:

          //something

          break;

  }

Is there a cleaner way to do this? Is is possible to store the possible Types in a dictionary and cast from that dictionary?

edited Jan 3 at 2:22

abatishchev

70.4k70267397

asked Jan 3 at 1:39

Twistingcashews

554

edited Jan 3 at 2:22

abatishchev

70.4k70267397

asked Jan 3 at 1:39

Twistingcashews

554

edited Jan 3 at 2:22

abatishchev

70.4k70267397

edited Jan 3 at 2:22

abatishchev

70.4k70267397

edited Jan 3 at 2:22

abatishchev

70.4k70267397

asked Jan 3 at 1:39

Twistingcashews

554

asked Jan 3 at 1:39

Twistingcashews

554

asked Jan 3 at 1:39

Twistingcashews

554

3

Maybe not an exact duplicate, but the same concept: Is there a better alternative than this to 'switch on type'? Some of the recent(ly-updated) answers discuss switching on a Type.

– BACON
Jan 3 at 1:49

You might also be interested in C# 8.0 switch expressions (as opposed to statements).

– Theraot
Jan 3 at 2:04

See stackoverflow.com/a/299001/41956. Would it work for you?

– abatishchev
Jan 3 at 2:22

Why you don't want to declare an abstract method which is called here and redefined by each subtype?

– dyukha
Jan 3 at 2:26

add a comment |

3

Maybe not an exact duplicate, but the same concept: Is there a better alternative than this to 'switch on type'? Some of the recent(ly-updated) answers discuss switching on a Type.

– BACON
Jan 3 at 1:49

You might also be interested in C# 8.0 switch expressions (as opposed to statements).

– Theraot
Jan 3 at 2:04

See stackoverflow.com/a/299001/41956. Would it work for you?

– abatishchev
Jan 3 at 2:22

Why you don't want to declare an abstract method which is called here and redefined by each subtype?

– dyukha
Jan 3 at 2:26

Maybe not an exact duplicate, but the same concept: Is there a better alternative than this to 'switch on type'? Some of the recent(ly-updated) answers discuss switching on a Type.

– BACON
Jan 3 at 1:49

You might also be interested in C# 8.0 switch expressions (as opposed to statements).

– Theraot
Jan 3 at 2:04

See stackoverflow.com/a/299001/41956. Would it work for you?

– abatishchev
Jan 3 at 2:22

Why you don't want to declare an abstract method which is called here and redefined by each subtype?

– dyukha
Jan 3 at 2:26

add a comment |

6 Answers
6

active

oldest

votes

Pattern Matching

To start I want to present the use of pattern matching in switch statements to work with different types, as follows:

public static double ComputeAreaModernSwitch(object shape)

{

    switch (shape)

    {

        case Square s:

            return s.Side * s.Side;

        case Circle c:

            return c.Radius * c.Radius * Math.PI;

        case Rectangle r:

            return r.Height * r.Length;

        default:

            throw new ArgumentException(

                message: "shape is not a recognized shape",

                paramName: nameof(shape));

    }

}

Example taken from Pattern Matching - C# Guide.

Type Dictionary

With that out of the way, yes, you can write a dictionary... the trouble will be on the type of the items.

We can do this:

Dictionary<Type, Action<object>> dictionary;



// (initialize and populate somewhere else) ...



if (dictionary.TryGetValue(element.GetType(), out var action))

{

    action(element);

}

However, here you have to use Action<object> because we need to give a type to the items (and no, we can't say Action<?> - well, we can do Action<dynamic> but you cannot cast Action<someType> to Action<dynamic>), forcing you to cast inside the called method.

We can argue that a cast is a way to tell the compiler that we know something it does not. In this case that we know that that object is actually of a given type.

We could do a bit better/worse, depending on how you look at it...

Dictionary<Type, Delegate> dictionary;



// (initialize and populate somewhere else) ...



if (dictionary.TryGetValue(element.GetType(), out var @delegate))

{

    @delegate.DynamicInvoke(element);

}

This is effectively late binding. We do not know the types at compile time... as developer you must ensure you provide a delegate of the correct type. However, if we are already enforcing knowledge that the compiler is unaware of, then this could be acceptable.

We can make a helper method to make it easier:

void SetMethod<T>(Action<T> action)

{

    dictionary[typeof(T)] = action;

}

Here the compiler can check the type for the method is correct. Yet, from the point of view of the compiler this information is lost (not available) when you consume the dictionary. It is a kind of type erasure if you will.

Dynamic

Now, if we are forgoing types, we could use dynamic following good answer by TheGeneral.

Addendum: Calling a known method (with MethodInfo)

You can call a method by its name, for example, if you have the following:

class Helper

{

    public static void Method(T input)

    {

        Console.WriteLine(input.GetType());

    }

}

You can do this:

var methodInfo = typeof(Helper).GetMethod("Method");



// ...



methodInfo.Invoke(null, new object{element});

You could then put all your methods in a helper class, and find them by the name (which you could derive from the name of the type).

If you want to call a known method that has a generic parameter, you can use MethodInfo. We need to be aware of whatever or not the method is static, and whatever or not the generic argument is part of the method definition or the declaring type definition...

On one hand, if you have something like this:

class Helper<T>

{

    public static void Method(T input)

    {

        Console.WriteLine(input.GetType());

    }

}

You can do this:

var helperType = typeof(Helper<>);



// ...



var specificMethodInfo = helperType.MakeGenericType(element.GetType()).GetMethod("Method");

specificMethodInfo.Invoke(null, new object{element});

On the other hand, if you have this:

class Helper

{

    public static void Method<T>(T input)

    {

        Console.WriteLine(input.GetType());

    }

}

You can do this:

var methodInfo = typeof(Helper).GetMethod("Method");



// ...



var specificMethodInfo = methodInfo.MakeGenericMethod(element.GetType());

specificMethodInfo.Invoke(null, new object{element});

Note: I pass null as first parameter to invoke. That is the instance on which I am calling the method. None, because they are static. If they aren't then you need an instance... you could try creating one with Activator.CreateInstance, for example.

Addendum: Finding what to call (Type Discovery)

Perhaps you have disparate method to call (they are not the same but with different generic argument), but you do not want to have the trouble of populate the dictionary by hand.

That is where Type Discovery comes in.

To begin with, I suggest to use an attribute, for example:

[AttributeUsage(AttributeTargets.Method)]

public sealed class DataHandlerAttribute : Attribute { }

Then we need a list of the types where we will search. If we will search on a known assembly we could do this:

var assembly = typeof(KnownType).GetTypeInfo().Assembly;

var types = assembly.GetTypes();

Note: if your target platform does not support this (.NET Standard 1.0 to 1.4), you will have to hand code the list of types.

Next, we need a predicate to check if a given type is one of the ones in which we are interested:

bool IsDataHandlerMethod(MethodInfo methodInfo)

{

    var dataHandlerAttributes = return (DataHandlerAttribute)item.GetCustomAttributes(typeof(DataHandlerAttribute), true);

    if (attributes == null || attributes.Length == 0)

    {

        return false;

    }

    if (methodInfo.DeclaringType != null)

    {

        return false;

    }

    if (methodInfo.ReturnTpye != typeof(void))

    {

        return false;

    }

    var parameters = methodInfo.GetParameters();

    if (parameters.Length != 1)

    {

        return false;

    }

    if (paramters[0].IsByRef || paramters[0].IsOut)

    {

        return false;

    }

    return true;

}

And a method to convert them into delegates:

(Type, Delegate) GetTypeDelegatePair(MethodInfo methodInfo)

{

    var parameters = methodInfo.GetParameters();

    var parameterType = parameters[0].ParameterType;

    var parameterTypeArray = new {parameterType};

    var delegateType = typeof(Action<>).MakeGenericType(parameterTypeArray);

    var target = null;

    if (!methodInfo.IsStatic)

    {

        var declaringType = methodInfo.DeclaringType;

        target = instance = Activator.CreateInstance(declaringType);

    }

    return (parameterType, methodInfo.CreateDelegate(delegateType, target));

}

And now we can do this:

var dataHandlers = types

            .SelectMany(t => t.GetTypeInfo().GetMethods())

            .Where(IsDataHandlerMethod)

            .Select(GetTypeDelegatePair);

And we will have an enumerable of pairs of types and delegate that we can use to populate our dictionary.

Note: the above code still needs some work (for example, could we just call GetParameters once?), and presumes a modern .NET target (extra work is needed to make it work in older platforms). Also notice the code for Type Discovery I present does not handle generic methods, you can check Type.IsGenericTypeDefinition and MethodInfo.IsGenericMethodDefinition... however, I would suggest to avoid them. In fact, it should be easy to modify for the case where you want to put all the methods in a single static class. You may also use a similar approach to get factory methods, for example.

edited Jan 3 at 3:46

answered Jan 3 at 1:57

Theraot

12.9k43459

add a comment |

If you have overloads, and you don't want to use a switch, you could use dynamic, however you really need to ask your self if this is a design problem, and should be solved in a more appropriate way. I.e why do you need to store unrelated types in a list anyway.

public static void Test(Version version)

{

   Console.WriteLine("is a version");

}

public static void Test(FormatException formatException)

{

   Console.WriteLine("is a formatException");

}

static void Main(string args)

{



   var list = new List<object>();

   list.Add(new Version());

   list.Add(new FormatException());



   foreach (var item in list)

      Test((dynamic)item);  

}

Output

is a version

is a formatException

Full Demo Here

Note : this will all break if it cant find an overload. ka-bang! So i don't recommend using it, unless you really really really need to

edited Jan 3 at 2:18

answered Jan 3 at 1:54

Michael Randall

37.1k84170

add a comment |

You can actually use standard System properties and methods to achieve your goal.

The first thing to do is get the Type:

var type = System.Type.GetType(elements.Name, false, true);

The false parameter indicates that you do not want to throw an exception on error and the true parameter indicates that you want to ignore case.

Once you have a valid type, you can call System.Activator to create a new instance of the class:

if (type != null) {

   var classInstance = System.ServiceActivator.CreateInstance(type);

   // Use the instance here

}

Note that this overload of CreateInstance requires a parameterless, public constructor. However, there are other overloads that allow you to pass parameters and access non-public constructors.

answered Jan 3 at 1:51

competent_tech

40.2k106599

add a comment |

You can use Type.GetType method to get the type of object instead of doing a string comparision. Here's the same code:

foreach (var element in ListOfObjects)

{

    var type = Type.GetType(element.Name);

    if (type == typeof(YOUR_OBJECT_TYPE))

    {

           // Do Something

    }



}

Read more about GetType here

answered Jan 3 at 1:51

Ankit Vijay

1,0781532

add a comment |

I am not sure if i understand your question clearly but,
maybe it can help you, I don't think you need to keep type in name field since you can get type just like this. And i also don't get why do you want to cast this type again to itself.

foreach (var element in ListOfObjects)

{

var _type = element.getType()

}

and you can just use switch case or if statements for making route.

edited Jan 3 at 2:10

answered Jan 3 at 1:59

Çağrı Şentuğ

add a comment |

Surely using dictionary mapping Type and Method is possible:

Dictionary<Type, Action<Object>> methodMap = new Dictionary<Type, Action<Object>>();

Preloading the dictionary:

static void Action1(Object obj)

{

  //do necessary casting here or not

  Console.WriteLine("i handle Type1");

}

static void Action2(Object obj)

{

   Console.WriteLine("i handle Type2");

}

Dictionary<Type, Action<Object>> methodMap = new Dictionary<Type, Action<Object>>();

methodMap[typeof(Type1)] = Action1;

methodMap[typeof(Type2)] = Action2;

And use the dictionary:

List<Object> collector = new List<Object>();

collector.Add(new Type1());

collector.Add(new Type2());



methodMap[collector[0].GetType()](collector[0]);

methodMap[collector[1].GetType()](collector[1]);

The type-method map also works for those class who's ancient is different. it would be the key factor you choose this kind method rather overloading or virtual member function.

answered Jan 3 at 2:26

Ju-Hsien Lai

30438

add a comment |

Your Answer

StackExchange.ifUsing("editor", function () {
StackExchange.using("externalEditor", function () {
StackExchange.using("snippets", function () {
StackExchange.snippets.init();
});
});
}, "code-snippets");

StackExchange.ready(function() {
var channelOptions = {
tags: "".split(" "),
id: "1"
};
initTagRenderer("".split(" "), "".split(" "), channelOptions);

StackExchange.using("externalEditor", function() {
// Have to fire editor after snippets, if snippets enabled
if (StackExchange.settings.snippets.snippetsEnabled) {
StackExchange.using("snippets", function() {
createEditor();
});
}
else {
createEditor();
}
});

function createEditor() {
StackExchange.prepareEditor({
heartbeatType: 'answer',
autoActivateHeartbeat: false,
convertImagesToLinks: true,
noModals: true,
showLowRepImageUploadWarning: true,
reputationToPostImages: 10,
bindNavPrevention: true,
postfix: "",
imageUploader: {
brandingHtml: "Powered by u003ca class="icon-imgur-white" href="https://imgur.com/"u003eu003c/au003e",
contentPolicyHtml: "User contributions licensed under u003ca href="https://creativecommons.org/licenses/by-sa/3.0/"u003ecc by-sa 3.0 with attribution requiredu003c/au003e u003ca href="https://stackoverflow.com/legal/content-policy"u003e(content policy)u003c/au003e",
allowUrls: true
},
onDemand: true,
discardSelector: ".discard-answer"
,immediatelyShowMarkdownHelp:true
});

}
});

draft saved

draft discarded

Sign up or log in

StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});

Post as a guest

Name

Required, but never shown

StackExchange.ready(
function () {
StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fstackoverflow.com%2fquestions%2f54015330%2f%25d0%25a1asting-a-variable-to-a-type-without-switch-case%23new-answer', 'question_page');
}
);

Post as a guest

Name

Required, but never shown

6 Answers
6

active

oldest

votes

6 Answers
6

active

oldest

votes

Pattern Matching

To start I want to present the use of pattern matching in switch statements to work with different types, as follows:

public static double ComputeAreaModernSwitch(object shape)

{

    switch (shape)

    {

        case Square s:

            return s.Side * s.Side;

        case Circle c:

            return c.Radius * c.Radius * Math.PI;

        case Rectangle r:

            return r.Height * r.Length;

        default:

            throw new ArgumentException(

                message: "shape is not a recognized shape",

                paramName: nameof(shape));

    }

}

Example taken from Pattern Matching - C# Guide.

Type Dictionary

With that out of the way, yes, you can write a dictionary... the trouble will be on the type of the items.

We can do this:

Dictionary<Type, Action<object>> dictionary;



// (initialize and populate somewhere else) ...



if (dictionary.TryGetValue(element.GetType(), out var action))

{

    action(element);

}

We can argue that a cast is a way to tell the compiler that we know something it does not. In this case that we know that that object is actually of a given type.

We could do a bit better/worse, depending on how you look at it...

Dictionary<Type, Delegate> dictionary;



// (initialize and populate somewhere else) ...



if (dictionary.TryGetValue(element.GetType(), out var @delegate))

{

    @delegate.DynamicInvoke(element);

}

We can make a helper method to make it easier:

void SetMethod<T>(Action<T> action)

{

    dictionary[typeof(T)] = action;

}

Dynamic

Now, if we are forgoing types, we could use dynamic following good answer by TheGeneral.

Addendum: Calling a known method (with MethodInfo)

You can call a method by its name, for example, if you have the following:

class Helper

{

    public static void Method(T input)

    {

        Console.WriteLine(input.GetType());

    }

}

You can do this:

var methodInfo = typeof(Helper).GetMethod("Method");



// ...



methodInfo.Invoke(null, new object{element});

You could then put all your methods in a helper class, and find them by the name (which you could derive from the name of the type).

On one hand, if you have something like this:

class Helper<T>

{

    public static void Method(T input)

    {

        Console.WriteLine(input.GetType());

    }

}

You can do this:

var helperType = typeof(Helper<>);



// ...



var specificMethodInfo = helperType.MakeGenericType(element.GetType()).GetMethod("Method");

specificMethodInfo.Invoke(null, new object{element});

On the other hand, if you have this:

class Helper

{

    public static void Method<T>(T input)

    {

        Console.WriteLine(input.GetType());

    }

}

You can do this:

var methodInfo = typeof(Helper).GetMethod("Method");



// ...



var specificMethodInfo = methodInfo.MakeGenericMethod(element.GetType());

specificMethodInfo.Invoke(null, new object{element});

Addendum: Finding what to call (Type Discovery)

Perhaps you have disparate method to call (they are not the same but with different generic argument), but you do not want to have the trouble of populate the dictionary by hand.

That is where Type Discovery comes in.

To begin with, I suggest to use an attribute, for example:

[AttributeUsage(AttributeTargets.Method)]

public sealed class DataHandlerAttribute : Attribute { }

Then we need a list of the types where we will search. If we will search on a known assembly we could do this:

var assembly = typeof(KnownType).GetTypeInfo().Assembly;

var types = assembly.GetTypes();

Note: if your target platform does not support this (.NET Standard 1.0 to 1.4), you will have to hand code the list of types.

Next, we need a predicate to check if a given type is one of the ones in which we are interested:

bool IsDataHandlerMethod(MethodInfo methodInfo)

{

    var dataHandlerAttributes = return (DataHandlerAttribute)item.GetCustomAttributes(typeof(DataHandlerAttribute), true);

    if (attributes == null || attributes.Length == 0)

    {

        return false;

    }

    if (methodInfo.DeclaringType != null)

    {

        return false;

    }

    if (methodInfo.ReturnTpye != typeof(void))

    {

        return false;

    }

    var parameters = methodInfo.GetParameters();

    if (parameters.Length != 1)

    {

        return false;

    }

    if (paramters[0].IsByRef || paramters[0].IsOut)

    {

        return false;

    }

    return true;

}

And a method to convert them into delegates:

(Type, Delegate) GetTypeDelegatePair(MethodInfo methodInfo)

{

    var parameters = methodInfo.GetParameters();

    var parameterType = parameters[0].ParameterType;

    var parameterTypeArray = new {parameterType};

    var delegateType = typeof(Action<>).MakeGenericType(parameterTypeArray);

    var target = null;

    if (!methodInfo.IsStatic)

    {

        var declaringType = methodInfo.DeclaringType;

        target = instance = Activator.CreateInstance(declaringType);

    }

    return (parameterType, methodInfo.CreateDelegate(delegateType, target));

}

And now we can do this:

var dataHandlers = types

            .SelectMany(t => t.GetTypeInfo().GetMethods())

            .Where(IsDataHandlerMethod)

            .Select(GetTypeDelegatePair);

And we will have an enumerable of pairs of types and delegate that we can use to populate our dictionary.

edited Jan 3 at 3:46

answered Jan 3 at 1:57

Theraot

12.9k43459

add a comment |

Pattern Matching

To start I want to present the use of pattern matching in switch statements to work with different types, as follows:

public static double ComputeAreaModernSwitch(object shape)

{

    switch (shape)

    {

        case Square s:

            return s.Side * s.Side;

        case Circle c:

            return c.Radius * c.Radius * Math.PI;

        case Rectangle r:

            return r.Height * r.Length;

        default:

            throw new ArgumentException(

                message: "shape is not a recognized shape",

                paramName: nameof(shape));

    }

}

Example taken from Pattern Matching - C# Guide.

Type Dictionary

With that out of the way, yes, you can write a dictionary... the trouble will be on the type of the items.

We can do this:

Dictionary<Type, Action<object>> dictionary;



// (initialize and populate somewhere else) ...



if (dictionary.TryGetValue(element.GetType(), out var action))

{

    action(element);

}

We can argue that a cast is a way to tell the compiler that we know something it does not. In this case that we know that that object is actually of a given type.

We could do a bit better/worse, depending on how you look at it...

Dictionary<Type, Delegate> dictionary;



// (initialize and populate somewhere else) ...



if (dictionary.TryGetValue(element.GetType(), out var @delegate))

{

    @delegate.DynamicInvoke(element);

}

We can make a helper method to make it easier:

void SetMethod<T>(Action<T> action)

{

    dictionary[typeof(T)] = action;

}

Dynamic

Now, if we are forgoing types, we could use dynamic following good answer by TheGeneral.

Addendum: Calling a known method (with MethodInfo)

You can call a method by its name, for example, if you have the following:

class Helper

{

    public static void Method(T input)

    {

        Console.WriteLine(input.GetType());

    }

}

You can do this:

var methodInfo = typeof(Helper).GetMethod("Method");



// ...



methodInfo.Invoke(null, new object{element});

You could then put all your methods in a helper class, and find them by the name (which you could derive from the name of the type).

On one hand, if you have something like this:

class Helper<T>

{

    public static void Method(T input)

    {

        Console.WriteLine(input.GetType());

    }

}

You can do this:

var helperType = typeof(Helper<>);



// ...



var specificMethodInfo = helperType.MakeGenericType(element.GetType()).GetMethod("Method");

specificMethodInfo.Invoke(null, new object{element});

On the other hand, if you have this:

class Helper

{

    public static void Method<T>(T input)

    {

        Console.WriteLine(input.GetType());

    }

}

You can do this:

var methodInfo = typeof(Helper).GetMethod("Method");



// ...



var specificMethodInfo = methodInfo.MakeGenericMethod(element.GetType());

specificMethodInfo.Invoke(null, new object{element});

Addendum: Finding what to call (Type Discovery)

Perhaps you have disparate method to call (they are not the same but with different generic argument), but you do not want to have the trouble of populate the dictionary by hand.

That is where Type Discovery comes in.

To begin with, I suggest to use an attribute, for example:

[AttributeUsage(AttributeTargets.Method)]

public sealed class DataHandlerAttribute : Attribute { }

Then we need a list of the types where we will search. If we will search on a known assembly we could do this:

var assembly = typeof(KnownType).GetTypeInfo().Assembly;

var types = assembly.GetTypes();

Note: if your target platform does not support this (.NET Standard 1.0 to 1.4), you will have to hand code the list of types.

Next, we need a predicate to check if a given type is one of the ones in which we are interested:

bool IsDataHandlerMethod(MethodInfo methodInfo)

{

    var dataHandlerAttributes = return (DataHandlerAttribute)item.GetCustomAttributes(typeof(DataHandlerAttribute), true);

    if (attributes == null || attributes.Length == 0)

    {

        return false;

    }

    if (methodInfo.DeclaringType != null)

    {

        return false;

    }

    if (methodInfo.ReturnTpye != typeof(void))

    {

        return false;

    }

    var parameters = methodInfo.GetParameters();

    if (parameters.Length != 1)

    {

        return false;

    }

    if (paramters[0].IsByRef || paramters[0].IsOut)

    {

        return false;

    }

    return true;

}

And a method to convert them into delegates:

(Type, Delegate) GetTypeDelegatePair(MethodInfo methodInfo)

{

    var parameters = methodInfo.GetParameters();

    var parameterType = parameters[0].ParameterType;

    var parameterTypeArray = new {parameterType};

    var delegateType = typeof(Action<>).MakeGenericType(parameterTypeArray);

    var target = null;

    if (!methodInfo.IsStatic)

    {

        var declaringType = methodInfo.DeclaringType;

        target = instance = Activator.CreateInstance(declaringType);

    }

    return (parameterType, methodInfo.CreateDelegate(delegateType, target));

}

And now we can do this:

var dataHandlers = types

            .SelectMany(t => t.GetTypeInfo().GetMethods())

            .Where(IsDataHandlerMethod)

            .Select(GetTypeDelegatePair);

And we will have an enumerable of pairs of types and delegate that we can use to populate our dictionary.

edited Jan 3 at 3:46

answered Jan 3 at 1:57

Theraot

12.9k43459

add a comment |

Pattern Matching

To start I want to present the use of pattern matching in switch statements to work with different types, as follows:

public static double ComputeAreaModernSwitch(object shape)

{

    switch (shape)

    {

        case Square s:

            return s.Side * s.Side;

        case Circle c:

            return c.Radius * c.Radius * Math.PI;

        case Rectangle r:

            return r.Height * r.Length;

        default:

            throw new ArgumentException(

                message: "shape is not a recognized shape",

                paramName: nameof(shape));

    }

}

Example taken from Pattern Matching - C# Guide.

Type Dictionary

With that out of the way, yes, you can write a dictionary... the trouble will be on the type of the items.

We can do this:

Dictionary<Type, Action<object>> dictionary;



// (initialize and populate somewhere else) ...



if (dictionary.TryGetValue(element.GetType(), out var action))

{

    action(element);

}

We can argue that a cast is a way to tell the compiler that we know something it does not. In this case that we know that that object is actually of a given type.

We could do a bit better/worse, depending on how you look at it...

Dictionary<Type, Delegate> dictionary;



// (initialize and populate somewhere else) ...



if (dictionary.TryGetValue(element.GetType(), out var @delegate))

{

    @delegate.DynamicInvoke(element);

}

We can make a helper method to make it easier:

void SetMethod<T>(Action<T> action)

{

    dictionary[typeof(T)] = action;

}

Dynamic

Now, if we are forgoing types, we could use dynamic following good answer by TheGeneral.

Addendum: Calling a known method (with MethodInfo)

You can call a method by its name, for example, if you have the following:

class Helper

{

    public static void Method(T input)

    {

        Console.WriteLine(input.GetType());

    }

}

You can do this:

var methodInfo = typeof(Helper).GetMethod("Method");



// ...



methodInfo.Invoke(null, new object{element});

You could then put all your methods in a helper class, and find them by the name (which you could derive from the name of the type).

On one hand, if you have something like this:

class Helper<T>

{

    public static void Method(T input)

    {

        Console.WriteLine(input.GetType());

    }

}

You can do this:

var helperType = typeof(Helper<>);



// ...



var specificMethodInfo = helperType.MakeGenericType(element.GetType()).GetMethod("Method");

specificMethodInfo.Invoke(null, new object{element});

On the other hand, if you have this:

class Helper

{

    public static void Method<T>(T input)

    {

        Console.WriteLine(input.GetType());

    }

}

You can do this:

var methodInfo = typeof(Helper).GetMethod("Method");



// ...



var specificMethodInfo = methodInfo.MakeGenericMethod(element.GetType());

specificMethodInfo.Invoke(null, new object{element});

Addendum: Finding what to call (Type Discovery)

Perhaps you have disparate method to call (they are not the same but with different generic argument), but you do not want to have the trouble of populate the dictionary by hand.

That is where Type Discovery comes in.

To begin with, I suggest to use an attribute, for example:

[AttributeUsage(AttributeTargets.Method)]

public sealed class DataHandlerAttribute : Attribute { }

Then we need a list of the types where we will search. If we will search on a known assembly we could do this:

var assembly = typeof(KnownType).GetTypeInfo().Assembly;

var types = assembly.GetTypes();

Note: if your target platform does not support this (.NET Standard 1.0 to 1.4), you will have to hand code the list of types.

Next, we need a predicate to check if a given type is one of the ones in which we are interested:

bool IsDataHandlerMethod(MethodInfo methodInfo)

{

    var dataHandlerAttributes = return (DataHandlerAttribute)item.GetCustomAttributes(typeof(DataHandlerAttribute), true);

    if (attributes == null || attributes.Length == 0)

    {

        return false;

    }

    if (methodInfo.DeclaringType != null)

    {

        return false;

    }

    if (methodInfo.ReturnTpye != typeof(void))

    {

        return false;

    }

    var parameters = methodInfo.GetParameters();

    if (parameters.Length != 1)

    {

        return false;

    }

    if (paramters[0].IsByRef || paramters[0].IsOut)

    {

        return false;

    }

    return true;

}

And a method to convert them into delegates:

(Type, Delegate) GetTypeDelegatePair(MethodInfo methodInfo)

{

    var parameters = methodInfo.GetParameters();

    var parameterType = parameters[0].ParameterType;

    var parameterTypeArray = new {parameterType};

    var delegateType = typeof(Action<>).MakeGenericType(parameterTypeArray);

    var target = null;

    if (!methodInfo.IsStatic)

    {

        var declaringType = methodInfo.DeclaringType;

        target = instance = Activator.CreateInstance(declaringType);

    }

    return (parameterType, methodInfo.CreateDelegate(delegateType, target));

}

And now we can do this:

var dataHandlers = types

            .SelectMany(t => t.GetTypeInfo().GetMethods())

            .Where(IsDataHandlerMethod)

            .Select(GetTypeDelegatePair);

And we will have an enumerable of pairs of types and delegate that we can use to populate our dictionary.

edited Jan 3 at 3:46

answered Jan 3 at 1:57

Theraot

12.9k43459

Pattern Matching

To start I want to present the use of pattern matching in switch statements to work with different types, as follows:

public static double ComputeAreaModernSwitch(object shape)

{

    switch (shape)

    {

        case Square s:

            return s.Side * s.Side;

        case Circle c:

            return c.Radius * c.Radius * Math.PI;

        case Rectangle r:

            return r.Height * r.Length;

        default:

            throw new ArgumentException(

                message: "shape is not a recognized shape",

                paramName: nameof(shape));

    }

}

Example taken from Pattern Matching - C# Guide.

Type Dictionary

With that out of the way, yes, you can write a dictionary... the trouble will be on the type of the items.

We can do this:

Dictionary<Type, Action<object>> dictionary;



// (initialize and populate somewhere else) ...



if (dictionary.TryGetValue(element.GetType(), out var action))

{

    action(element);

}

We can argue that a cast is a way to tell the compiler that we know something it does not. In this case that we know that that object is actually of a given type.

We could do a bit better/worse, depending on how you look at it...

Dictionary<Type, Delegate> dictionary;



// (initialize and populate somewhere else) ...



if (dictionary.TryGetValue(element.GetType(), out var @delegate))

{

    @delegate.DynamicInvoke(element);

}

We can make a helper method to make it easier:

void SetMethod<T>(Action<T> action)

{

    dictionary[typeof(T)] = action;

}

Dynamic

Now, if we are forgoing types, we could use dynamic following good answer by TheGeneral.

Addendum: Calling a known method (with MethodInfo)

You can call a method by its name, for example, if you have the following:

class Helper

{

    public static void Method(T input)

    {

        Console.WriteLine(input.GetType());

    }

}

You can do this:

var methodInfo = typeof(Helper).GetMethod("Method");



// ...



methodInfo.Invoke(null, new object{element});

You could then put all your methods in a helper class, and find them by the name (which you could derive from the name of the type).

On one hand, if you have something like this:

class Helper<T>

{

    public static void Method(T input)

    {

        Console.WriteLine(input.GetType());

    }

}

You can do this:

var helperType = typeof(Helper<>);



// ...



var specificMethodInfo = helperType.MakeGenericType(element.GetType()).GetMethod("Method");

specificMethodInfo.Invoke(null, new object{element});

On the other hand, if you have this:

class Helper

{

    public static void Method<T>(T input)

    {

        Console.WriteLine(input.GetType());

    }

}

You can do this:

var methodInfo = typeof(Helper).GetMethod("Method");



// ...



var specificMethodInfo = methodInfo.MakeGenericMethod(element.GetType());

specificMethodInfo.Invoke(null, new object{element});

Addendum: Finding what to call (Type Discovery)

Perhaps you have disparate method to call (they are not the same but with different generic argument), but you do not want to have the trouble of populate the dictionary by hand.

That is where Type Discovery comes in.

To begin with, I suggest to use an attribute, for example:

[AttributeUsage(AttributeTargets.Method)]

public sealed class DataHandlerAttribute : Attribute { }

Then we need a list of the types where we will search. If we will search on a known assembly we could do this:

var assembly = typeof(KnownType).GetTypeInfo().Assembly;

var types = assembly.GetTypes();

Note: if your target platform does not support this (.NET Standard 1.0 to 1.4), you will have to hand code the list of types.

Next, we need a predicate to check if a given type is one of the ones in which we are interested:

bool IsDataHandlerMethod(MethodInfo methodInfo)

{

    var dataHandlerAttributes = return (DataHandlerAttribute)item.GetCustomAttributes(typeof(DataHandlerAttribute), true);

    if (attributes == null || attributes.Length == 0)

    {

        return false;

    }

    if (methodInfo.DeclaringType != null)

    {

        return false;

    }

    if (methodInfo.ReturnTpye != typeof(void))

    {

        return false;

    }

    var parameters = methodInfo.GetParameters();

    if (parameters.Length != 1)

    {

        return false;

    }

    if (paramters[0].IsByRef || paramters[0].IsOut)

    {

        return false;

    }

    return true;

}

And a method to convert them into delegates:

(Type, Delegate) GetTypeDelegatePair(MethodInfo methodInfo)

{

    var parameters = methodInfo.GetParameters();

    var parameterType = parameters[0].ParameterType;

    var parameterTypeArray = new {parameterType};

    var delegateType = typeof(Action<>).MakeGenericType(parameterTypeArray);

    var target = null;

    if (!methodInfo.IsStatic)

    {

        var declaringType = methodInfo.DeclaringType;

        target = instance = Activator.CreateInstance(declaringType);

    }

    return (parameterType, methodInfo.CreateDelegate(delegateType, target));

}

And now we can do this:

var dataHandlers = types

            .SelectMany(t => t.GetTypeInfo().GetMethods())

            .Where(IsDataHandlerMethod)

            .Select(GetTypeDelegatePair);

And we will have an enumerable of pairs of types and delegate that we can use to populate our dictionary.

edited Jan 3 at 3:46

answered Jan 3 at 1:57

Theraot

12.9k43459

edited Jan 3 at 3:46

answered Jan 3 at 1:57

Theraot

12.9k43459

answered Jan 3 at 1:57

Theraot

12.9k43459

answered Jan 3 at 1:57

Theraot

12.9k43459

add a comment |

public static void Test(Version version)

{

   Console.WriteLine("is a version");

}

public static void Test(FormatException formatException)

{

   Console.WriteLine("is a formatException");

}

static void Main(string args)

{



   var list = new List<object>();

   list.Add(new Version());

   list.Add(new FormatException());



   foreach (var item in list)

      Test((dynamic)item);  

}

Output

is a version

is a formatException

Full Demo Here

Note : this will all break if it cant find an overload. ka-bang! So i don't recommend using it, unless you really really really need to

edited Jan 3 at 2:18

answered Jan 3 at 1:54

Michael Randall

37.1k84170

add a comment |

public static void Test(Version version)

{

   Console.WriteLine("is a version");

}

public static void Test(FormatException formatException)

{

   Console.WriteLine("is a formatException");

}

static void Main(string args)

{



   var list = new List<object>();

   list.Add(new Version());

   list.Add(new FormatException());



   foreach (var item in list)

      Test((dynamic)item);  

}

Output

is a version

is a formatException

Full Demo Here

Note : this will all break if it cant find an overload. ka-bang! So i don't recommend using it, unless you really really really need to

edited Jan 3 at 2:18

answered Jan 3 at 1:54

Michael Randall

37.1k84170

add a comment |

public static void Test(Version version)

{

   Console.WriteLine("is a version");

}

public static void Test(FormatException formatException)

{

   Console.WriteLine("is a formatException");

}

static void Main(string args)

{



   var list = new List<object>();

   list.Add(new Version());

   list.Add(new FormatException());



   foreach (var item in list)

      Test((dynamic)item);  

}

Output

is a version

is a formatException

Full Demo Here

Note : this will all break if it cant find an overload. ka-bang! So i don't recommend using it, unless you really really really need to

edited Jan 3 at 2:18

answered Jan 3 at 1:54

Michael Randall

37.1k84170

public static void Test(Version version)

{

   Console.WriteLine("is a version");

}

public static void Test(FormatException formatException)

{

   Console.WriteLine("is a formatException");

}

static void Main(string args)

{



   var list = new List<object>();

   list.Add(new Version());

   list.Add(new FormatException());



   foreach (var item in list)

      Test((dynamic)item);  

}

Output

is a version

is a formatException

Full Demo Here

Note : this will all break if it cant find an overload. ka-bang! So i don't recommend using it, unless you really really really need to

edited Jan 3 at 2:18

answered Jan 3 at 1:54

Michael Randall

37.1k84170

edited Jan 3 at 2:18

answered Jan 3 at 1:54

Michael Randall

37.1k84170

answered Jan 3 at 1:54

Michael Randall

37.1k84170

answered Jan 3 at 1:54

Michael Randall

37.1k84170

add a comment |

You can actually use standard System properties and methods to achieve your goal.

The first thing to do is get the Type:

var type = System.Type.GetType(elements.Name, false, true);

The false parameter indicates that you do not want to throw an exception on error and the true parameter indicates that you want to ignore case.

Once you have a valid type, you can call System.Activator to create a new instance of the class:

if (type != null) {

   var classInstance = System.ServiceActivator.CreateInstance(type);

   // Use the instance here

}

Note that this overload of CreateInstance requires a parameterless, public constructor. However, there are other overloads that allow you to pass parameters and access non-public constructors.

answered Jan 3 at 1:51

competent_tech

40.2k106599

add a comment |

You can actually use standard System properties and methods to achieve your goal.

The first thing to do is get the Type:

var type = System.Type.GetType(elements.Name, false, true);

The false parameter indicates that you do not want to throw an exception on error and the true parameter indicates that you want to ignore case.

Once you have a valid type, you can call System.Activator to create a new instance of the class:

if (type != null) {

   var classInstance = System.ServiceActivator.CreateInstance(type);

   // Use the instance here

}

Note that this overload of CreateInstance requires a parameterless, public constructor. However, there are other overloads that allow you to pass parameters and access non-public constructors.

answered Jan 3 at 1:51

competent_tech

40.2k106599

add a comment |

You can actually use standard System properties and methods to achieve your goal.

The first thing to do is get the Type:

var type = System.Type.GetType(elements.Name, false, true);

The false parameter indicates that you do not want to throw an exception on error and the true parameter indicates that you want to ignore case.

Once you have a valid type, you can call System.Activator to create a new instance of the class:

if (type != null) {

   var classInstance = System.ServiceActivator.CreateInstance(type);

   // Use the instance here

}

Note that this overload of CreateInstance requires a parameterless, public constructor. However, there are other overloads that allow you to pass parameters and access non-public constructors.

answered Jan 3 at 1:51

competent_tech

40.2k106599

You can actually use standard System properties and methods to achieve your goal.

The first thing to do is get the Type:

var type = System.Type.GetType(elements.Name, false, true);

The false parameter indicates that you do not want to throw an exception on error and the true parameter indicates that you want to ignore case.

Once you have a valid type, you can call System.Activator to create a new instance of the class:

if (type != null) {

   var classInstance = System.ServiceActivator.CreateInstance(type);

   // Use the instance here

}

Note that this overload of CreateInstance requires a parameterless, public constructor. However, there are other overloads that allow you to pass parameters and access non-public constructors.

answered Jan 3 at 1:51

competent_tech

40.2k106599

answered Jan 3 at 1:51

competent_tech

40.2k106599

answered Jan 3 at 1:51

competent_tech

40.2k106599

answered Jan 3 at 1:51

competent_tech

40.2k106599

add a comment |

You can use Type.GetType method to get the type of object instead of doing a string comparision. Here's the same code:

foreach (var element in ListOfObjects)

{

    var type = Type.GetType(element.Name);

    if (type == typeof(YOUR_OBJECT_TYPE))

    {

           // Do Something

    }



}

Read more about GetType here

answered Jan 3 at 1:51

Ankit Vijay

1,0781532

add a comment |

You can use Type.GetType method to get the type of object instead of doing a string comparision. Here's the same code:

foreach (var element in ListOfObjects)

{

    var type = Type.GetType(element.Name);

    if (type == typeof(YOUR_OBJECT_TYPE))

    {

           // Do Something

    }



}

Read more about GetType here

answered Jan 3 at 1:51

Ankit Vijay

1,0781532

add a comment |

You can use Type.GetType method to get the type of object instead of doing a string comparision. Here's the same code:

foreach (var element in ListOfObjects)

{

    var type = Type.GetType(element.Name);

    if (type == typeof(YOUR_OBJECT_TYPE))

    {

           // Do Something

    }



}

Read more about GetType here

answered Jan 3 at 1:51

Ankit Vijay

1,0781532

You can use Type.GetType method to get the type of object instead of doing a string comparision. Here's the same code:

foreach (var element in ListOfObjects)

{

    var type = Type.GetType(element.Name);

    if (type == typeof(YOUR_OBJECT_TYPE))

    {

           // Do Something

    }



}

Read more about GetType here

answered Jan 3 at 1:51

Ankit Vijay

1,0781532

answered Jan 3 at 1:51

Ankit Vijay

1,0781532

answered Jan 3 at 1:51

Ankit Vijay

1,0781532

answered Jan 3 at 1:51

Ankit Vijay

1,0781532

add a comment |

foreach (var element in ListOfObjects)

{

var _type = element.getType()

}

and you can just use switch case or if statements for making route.

edited Jan 3 at 2:10

answered Jan 3 at 1:59

Çağrı Şentuğ

add a comment |

foreach (var element in ListOfObjects)

{

var _type = element.getType()

}

and you can just use switch case or if statements for making route.

edited Jan 3 at 2:10

answered Jan 3 at 1:59

Çağrı Şentuğ

add a comment |

foreach (var element in ListOfObjects)

{

var _type = element.getType()

}

and you can just use switch case or if statements for making route.

edited Jan 3 at 2:10

answered Jan 3 at 1:59

Çağrı Şentuğ

foreach (var element in ListOfObjects)

{

var _type = element.getType()

}

and you can just use switch case or if statements for making route.

edited Jan 3 at 2:10

answered Jan 3 at 1:59

Çağrı Şentuğ

edited Jan 3 at 2:10

answered Jan 3 at 1:59

Çağrı Şentuğ

answered Jan 3 at 1:59

Çağrı Şentuğ

answered Jan 3 at 1:59

Çağrı Şentuğ

add a comment |

Surely using dictionary mapping Type and Method is possible:

Dictionary<Type, Action<Object>> methodMap = new Dictionary<Type, Action<Object>>();

Preloading the dictionary:

static void Action1(Object obj)

{

  //do necessary casting here or not

  Console.WriteLine("i handle Type1");

}

static void Action2(Object obj)

{

   Console.WriteLine("i handle Type2");

}

Dictionary<Type, Action<Object>> methodMap = new Dictionary<Type, Action<Object>>();

methodMap[typeof(Type1)] = Action1;

methodMap[typeof(Type2)] = Action2;

And use the dictionary:

List<Object> collector = new List<Object>();

collector.Add(new Type1());

collector.Add(new Type2());



methodMap[collector[0].GetType()](collector[0]);

methodMap[collector[1].GetType()](collector[1]);

The type-method map also works for those class who's ancient is different. it would be the key factor you choose this kind method rather overloading or virtual member function.

answered Jan 3 at 2:26

Ju-Hsien Lai

30438

add a comment |

Surely using dictionary mapping Type and Method is possible:

Dictionary<Type, Action<Object>> methodMap = new Dictionary<Type, Action<Object>>();

Preloading the dictionary:

static void Action1(Object obj)

{

  //do necessary casting here or not

  Console.WriteLine("i handle Type1");

}

static void Action2(Object obj)

{

   Console.WriteLine("i handle Type2");

}

Dictionary<Type, Action<Object>> methodMap = new Dictionary<Type, Action<Object>>();

methodMap[typeof(Type1)] = Action1;

methodMap[typeof(Type2)] = Action2;

And use the dictionary:

List<Object> collector = new List<Object>();

collector.Add(new Type1());

collector.Add(new Type2());



methodMap[collector[0].GetType()](collector[0]);

methodMap[collector[1].GetType()](collector[1]);

The type-method map also works for those class who's ancient is different. it would be the key factor you choose this kind method rather overloading or virtual member function.

answered Jan 3 at 2:26

Ju-Hsien Lai

30438

add a comment |

Surely using dictionary mapping Type and Method is possible:

Dictionary<Type, Action<Object>> methodMap = new Dictionary<Type, Action<Object>>();

Preloading the dictionary:

static void Action1(Object obj)

{

  //do necessary casting here or not

  Console.WriteLine("i handle Type1");

}

static void Action2(Object obj)

{

   Console.WriteLine("i handle Type2");

}

Dictionary<Type, Action<Object>> methodMap = new Dictionary<Type, Action<Object>>();

methodMap[typeof(Type1)] = Action1;

methodMap[typeof(Type2)] = Action2;

And use the dictionary:

List<Object> collector = new List<Object>();

collector.Add(new Type1());

collector.Add(new Type2());



methodMap[collector[0].GetType()](collector[0]);

methodMap[collector[1].GetType()](collector[1]);

The type-method map also works for those class who's ancient is different. it would be the key factor you choose this kind method rather overloading or virtual member function.

answered Jan 3 at 2:26

Ju-Hsien Lai

30438

Surely using dictionary mapping Type and Method is possible:

Dictionary<Type, Action<Object>> methodMap = new Dictionary<Type, Action<Object>>();

Preloading the dictionary:

static void Action1(Object obj)

{

  //do necessary casting here or not

  Console.WriteLine("i handle Type1");

}

static void Action2(Object obj)

{

   Console.WriteLine("i handle Type2");

}

Dictionary<Type, Action<Object>> methodMap = new Dictionary<Type, Action<Object>>();

methodMap[typeof(Type1)] = Action1;

methodMap[typeof(Type2)] = Action2;

And use the dictionary:

List<Object> collector = new List<Object>();

collector.Add(new Type1());

collector.Add(new Type2());



methodMap[collector[0].GetType()](collector[0]);

methodMap[collector[1].GetType()](collector[1]);

The type-method map also works for those class who's ancient is different. it would be the key factor you choose this kind method rather overloading or virtual member function.

answered Jan 3 at 2:26

Ju-Hsien Lai

30438

answered Jan 3 at 2:26

Ju-Hsien Lai

30438

answered Jan 3 at 2:26

Ju-Hsien Lai

30438

answered Jan 3 at 2:26

Ju-Hsien Lai

30438

add a comment |

draft saved

draft discarded

Thanks for contributing an answer to Stack Overflow!

Please be sure to answer the question. Provide details and share your research!

But avoid …

Asking for help, clarification, or responding to other answers.

Making statements based on opinion; back them up with references or personal experience.

To learn more, see our tips on writing great answers.

draft saved

draft discarded

Sign up or log in

StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});

Post as a guest

Name

Required, but never shown

Post as a guest

Name

Required, but never shown

Sign up or log in

StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});

Post as a guest

Name

Required, but never shown

Sign up or log in

StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});

Post as a guest

Name

Required, but never shown

Sign up or log in

StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});

Post as a guest

Name

Required, but never shown

Name

Required, but never shown

Name

Required, but never shown

This page is only for reference, If you need detailed information, please check here

Search This Blog

Ufyukyu