CODEWITHSUNDEEP
c#type-conversion
John Bustos
John Bustos

Reputation: 19544

Assign different types of variable to one type

As a very simplified and stupid example of what I'm dealing with, suppose I had the following class with a simple static int property:

public class MyClass
{
    public static int MyVar { get; set; }
}

So, if I wanted to set that property via code, it would be easy enough with something such as:

MyClass.MyVar = 2;

But, how could I take care of (again, to simplify the example) passing in a string and have it converted to an int?

The only way I could think of doing it is to create a helper method such as:

public class MyClass
{
    public static int MyVar { get; private set; }
    public static void SetMyVar(string sMyVar)
    {
        MyVar = int.Parse(sMyVar);
    }
}

And then in code run:

MyClass.SetMyVar("2");

I would love to know if there was a better way to accomplish this than having to add in that extra method.

Upvotes: 3

Views: 180

Answers (3)

Pete Baughman
Pete Baughman

Reputation: 3034

You can use the compiler's method overload resolution to pick a SetMyValue method depending on the type of the argument. Inside each SetMyValue method you have a mechanism to convert all of the different input values to the same underlying type.

Doing this is probably a bad idea - but here goes anyway. It doesn't have quite the semantics that you're asking for but it's close:

//A class with multiple 'set' methods that will silently handle
//type conversions
class MyClass{

  private int myValue;

  public int MyValue { { get return this.myValue; } }

  public void SetMyValue(int value){
    this.myValue = value;
  }

  public void SetMyValue(string value){
    this.myValue = Convert.ToInt32(value);
  }
}

In statically typed languages, switching types silently in a way that loses information is not a very wise idea. There are other, dynamically typed languages that let you play fast and loose with types but C# is not one of them. You have to go out of your way in C# to get dynamic typing.

Doing this is probably a pain in the butt from a maintenance standpoint. I would put some more thought into the underlying problem that you're trying to solve that lead to this question.

Upvotes: 0

d0nut
d0nut

Reputation: 2834

Although you definitely shouldn't do this because it's confusing to read, you could create the property this way

class MyClass
{
    private static int _property = 0;

    public static object Property
    {
        get
        {
            return _property;
        }
        set
        {
            _property = Convert.ToInt32(value);
        }
    }
}

You would have to cast this to an int whenever you wanted to use it as an integer but this is best I could think of.

Upvotes: 1

user4843530
user4843530

Reputation:

is this what you were trying to do?

    class newclass
    {
        private static int MyVarValue = 0;
        public static int MyVar
        {
            get;
            set
            {
                MyVarValue = Convert.ToInt32(value);
            }
        }
    }

This would not compile because the value that a property gets set to has to be of the same type as the property itself. But if you are taking a list of objects in a constructor and assigning them to the properties, there you can do something like this...

    class newclass
    {
        private static int MyVarValue = 0;
        public newclass(List<object> startingList)
        {
            MyVarValue = Convert.ToInt32(startingList[0]);
        }
    }

Upvotes: 0

Related Questions