Develop Reference

Override variable or class keeping the same name but changing types [duplicate]

The only time I tried to use object was List<object> and I regretted it and rewrote it. I can never find an instance to use object rather than an interface. When does one use object in .NET?

Frankly, it doesn't happen often that you REALLY need it. But when you do, it's pretty obvious. Reflection, generic type casting, serialization or tagging are among topic that ends up having object around.
It's like void*... which in essence is almost the same. You wonder what's the use for such "crude" item until you ends up in a corner with no way out, but to use it.
It's the lowest level you can find in managed code. Everything is an object, you cannot go deeper.
Generic Type casting:
public T AddComponents<T>()
{
Component component = (Component)Activator.CreateInstance(typeof(T));
if (component != null)
{
component.Parent = this;
components.Add(component);
}
return (T)(object)component; //Cannot directly cast Component to T since we have no constraint between them.
}
"Tags" of the idea of assigning an item to a generic container who has no idea of the content:
public class DragDropWrapper
{
private object tag;
public object Tag
{
get { return tag; }
}
}
What is dragged? No idea. Can be anything.
Or the very common Event Sender:
public void Message(object sender, string text)
{
Entry entry = new Entry(sender, EntryType.Message, text);
AddEntry(entry);
}
The sender can be anything.
Reflection to expand the property of an object:
public static List<InfoNode> ExpandObject(InfoGrid grid, InfoNode owner, object obj)
{
List<InfoNode> nodes = new List<InfoNode>();
if (obj == null)
return nodes;
PropertyInfo[] infos = obj.GetType().GetProperties(BindingFlags.FlattenHierarchy | BindingFlags.Instance | BindingFlags.Public);
foreach (PropertyInfo info in infos)
nodes.Add(new PropertyNode(grid, owner, obj, info));
nodes = nodes.OrderBy(n => n.Name).ToList();
return nodes;
}
And many many more possibilities.

Well, one very good example. Lets say you wanted to write a library, and this library needed to be able to take some arbitrary piece of data and store it. For example like in an ORM then you might write a function like so..
bool InsertObject(object item);
The same could be said for an object seralizer. think JSON.
Basically, you would 'use' object when you need to work in a very generic manner.

You use object when you need to store a reference to any object type. If that's something you don't need to do, then feel free to not use it.

One rarely uses object directly because it has so little functionality. It was used more frequently in V 1.0 (before generics), but now is rarely used for much more than the occasional doble cast like this:
(A)(object)someType;
to work around limitations of the cast operation.
The real purpose of object is to enforce the implementation of basic operations such as GetType() and ToString(), and provide a default implementation of those.

For example, i'd use it as a variable for lock in the class

Normally, you will primarily use the object type explicitly only when interacting with APIs that were written prior to generics being added to the C# language.
One use case that I do find fairly common is the following idiom:
class NeedsToBeThreadSafe {
private static object _lock = new object();
void ThreadSafeOperation() {
lock (_lock)
{
// Perform some useful work
}
}
}
Here, we need the _lock object only to implement the locking; it doesn't need any members or value—so the object type is appropriate.

Object is the parent type for all the types.Every single type that you create or use from the .Net framework inherits from it.Prior to generics being introduced in .Net,most of the collection types (for e.g ArrayList under System.Collecrtions) are defined to accept Object types.What it means is you could add have a Mixed bag of different types.And you need to cast the items to a specific type while retrieving.This is an unneeded overhead.
To answer your question.
You should avoid using object anywhere as it does not do any good to your code.The whole point of introducing generics was to get rid of object notation ,so you can avoid unneeded casts in your code.

As object can be used to reference any value, you use it when you need to do exactly that.
The String.Format method for example uses object parameters to be able to put any value in a string:
public string Format(string format, params object[] parameters)
That enables you to send any values into it, for example:
String.Format("{0} {1}", 1, "2");
Using it as a generic type, like in List<object>, is not so common as you usually have some more specific type that you can use. However, a List<object> would be the generic equivalent of the ArrayList class, which was frequently used before generics was introduced in .NET.

Object can be used when the API you are creating do not care about the underlying type, or can accept everything. For example I want to create a library that serializes everything. In that case the library methods receives an instance of object, and can handle the rest through reflection.
Or imagine you want to create a refactor friendly method that recieves a member-access lambda expression, as in:
f(something, s => s.member);
And you don't care about what the member type could be, it could be anything. You can define the method like:
void f(SomeType something, Expression<Func<SomeType, object>>) ...
Other common use is to use it as a thread lock variable, which other people have mentioned.

Casting to arbitrary non-generic return type at runtime, C#

I'm trying to make a user-friendly debug framework where users can create more debug variables as easily as possible.
I need to cast an object to the return type of my property/method (bool, int, whatever), without knowing what that return type is.
tldr: How can I return a non-generic type (in this example bool) from
public bool MyGetSetProperty {
get {
object obj = new object();
return (bool)obj;
}
}
WITHOUT specifying "return (bool)"? So something like
return (GenericThingHereThatPassesAsBool)obj;
or
return obj as MyGetSetPropertyReturnType;
----------
Detail:
I want users to be able to create new properties in this class as easily as possible - basically copying+pasting the whole code block below, and only replacing "SerializeAll" with their variable name, and the type declaration "bool" with the type they want on the field/property declarations.
In my getter, I have a couple separate checks to see if the entire debug system is enabled. If not, it returns a default value for the given variable.
[Tooltip ("Serialize ALL XML output fields?"), SerializeField]
private bool debugSerializeAll = false;
/// <summary>
/// Serialize ALL XML output fields?
/// </summary>
[DebugValue, DebugDefault (true)]
public bool SerializeAll {
get {
if (!classEnabled || !debug.debugEnabled)
return (bool)GetDefaultValue (MethodBase.GetCurrentMethod ());
return debugSerializeAll;
}
set { debugSerializeAll = value; }
}
The thing is, I can't return "default" because the default value can be overridden - see the "DebugDefault" attribute where the "default" value for this bool is actually "true", at least as far as my debug system is concerned. The method "GetDefaultValue" accommodates for that, and it returns an object that could be a string, int, bool, anything.
I'm already doing funky reflection stuff to access the MethodInfo, PropertyInfo, etc of the getter and property SerializeAll. I just can't figure out how to not have to also specify the (bool) cast on the return. Again, the goal is as little human editing as possible.
Thank you!

You should be able to do this with a cast to dynamic.
return (dynamic)GetDefaultValue (MethodBase.GetCurrentMethod ());
Bear in mind that the compiler isn't actually making this into a cast to bool. Rather, this makes the compiler ignore compile-time type-safety, and instead the program will use reflection at runtime to figure out the best way to take the value returned from GetDefaultValue and turn it into what it needs to be.
I want users to be able to create new properties in this class as easily as possible...
This is a good principle.
... basically copying+pasting the whole code block below, and only replacing "SerializeAll" with their variable name, and the type declaration "bool" with the type they want on the field/property declarations.
That totally breaks the principle you just mentioned, and results in a bunch of boilerplate code and other code smells.
In theory, you could probably create a Fody Weaver or something to add this boilerplate code upon compilation. But that's probably more work than it's worth.
I would hazard a guess that this is an "XY Problem", where you're asking how to achieve the solution that you've imagined, rather than asking how to solve the problem you're actually facing.
Why should every property in your class return a completely different value if certain private fields are set a certain way? This sounds like a big Separation of Concerns problem, where you're tasking your class with doing two completely different things. I strongly suggest you find another way to solve the problem you're trying to solve. For example, when code tries to get an instance of your class, it could go through a method that checks the classEnabled and debug.debugEnabled concepts (which probably belong in a different class), and returns an instance with the properties all set to their defaults.

Please Link click here -> How to cast Object to boolean?
or
I think you need to study for Generic class
Check if a class is derived from a generic class

Cast object into appropriate type for overloaded methods

Say I have a method that is overloaded such as void PrintInfo(Person) and void PrintInfo(Item), and so on. I try to invoke these methods by passing in an Object.
I'm wondering why it is giving me an error when I do this; aren't all classes inherited from Object? I want to avoid doing an if/switch statement where I check which type the Object is before calling the appropriate method.
What do you guys think is the best approach in this case?

All Persons are objects , but not all objects are Persons. Because of this you can pass a Person to a method that accepts an object but you can't pass an object to a method that requires a Person.
It sounds like you have some common bit of functionality between various objects that you want to use. Given this, it would be best to find either a common ancestor that has all of the functionality that you need, or an interface that they all implement (that again provides everything that you need).
In the case of printing, you may just need the ToString method. In that case, you can just have the method accept an object and call ToString on it. (That's what many print methods do, such as Console.WriteLine.

You need to understand that because C# is a statically typed language (barring dynamic) the particular overload that is chosen (called overload resolution) is determined at compile time, not run time. That means that the compiler needs to be able to unequivocally determine what type your argument is. Consider:
Object foo;
foo = "String";
foo = 5;
PrintInfo(foo); // Which overload of printinfo should be called? The compiler doesn't know!
There are a few ways to solve this- making foo of type dynamic is one- that will cause the correct overload to be chosen at compile time. The problem with that is that you lose type safety- if you don't have an appropriate overload for that type, your application will still compile but will crash when you try to print the unsupported type's info.
An arguably better approach is to ensure that foo is always of the correct type, rather than just Object.
As #Servy suggests, another approach is to attach the behavior to the type itself. You could, for instance, make an interface IHasPrintInfo:
public interface IHasPrintInfo { String PrintInfo { get; } }
and implement that interface on all items whose info you might print. Then your PrintInfo function can just take an IPrintInfo:
public void PrintInfo(IPrintInfo info) {
Console.WriteLine(info.PrintInfo);
}

here its ambiguate for compiler; compiler can't figure out which version of method (Person/Item) you are intended to call.

Implementation of `Class` like `String` Class

I want to implement class i.e. we have String class in .Net. In that, if you check when we code....
C#:
String strString = "Value-12346- .";
String[] strArray = strString.Substring(0, strString.Length - 1).TrimEnd().ToUpper().Split("-".ToCharArray());
in this example if you check we are calling multiple functions of String Class, over each function i.e over Substring function TrimEnd is called and over TrimEnd Split function is called. I would like to implement similar. Please help me out.
Many Thanks!!!

Make sure every method returns an object of the same type (or the type you want) and then you can call the methods on the object like that ( cascade or chain). Each of the above method in the string example returns a new string ( note that strings are immutable here ), so you can apply the string functions again and so on.
On a related note, see how Fluent Interface works. The C# example showing non-fluent and fluent API is a good example: http://en.wikipedia.org/wiki/Fluent_interface
public IConfigurationFluent SetColor(string newColor)
{
this.color = newColor;
return this;
}

As manojlds pointed out above, you achieve that by making your class' member methods return the type of their owner class. Now, in particular, the String's methods return a new string instance every time (instead of "modifying" the source and returning it), so you might want in your methods to create a deep copy of "this" and then made any changes to the new object and return it. Not only that, but the String class is immutable.
Sorry for being too detailed.

Type conversion from string to User defined type

I have a string type to be assigned to owner of type 'User'. My method GetFullName returns the name in a 'string' format and i need to assign it to owner of type 'User'
def.Owner = uf.GetFullName(row["assignedto"].ToString());
Any suggestions would be helpful,

So you need something like:
public class User
{
...
public static implicit operator User(string x)
{
return new User(x);
}
}
Personally, I'm not a fan of implicit conversions, however. You say that you "need" to assign it this way... what's wrong with an explicit constructor or static method call? Or perhaps an extension method (ToUser) on string?

#Jon's answer will do what you want, but you may want to look into the repository pattern for managing the creation of domain objects. That'll solve the bigger problem of making sure the code that uses the domain objects doesn't become wrapped around the axle just managing their lifetimes and serialization/deserialization. Let the repository take care of such concerns and focus on your domain logic.

There is a solution with conversion operator, however, I'd personally prefer a static class method like User.FromString(string s) that parses the string and constructs a User instance. This way the code with be more readable and much easier to understand

You can overload the explicit/implicit operators.
Take a look here