Pfthb

 public static bool EqualsMethod(**ValueType** value1, **ValueType** value2)
 
 bool result = false;
 Type t1 = value1.GetType();
 Type t2 = value2.GetType();
 var i = (**dynamic**)value1;
 var j = (**dynamic**)value2;
 

Can Anyone Please Tell me instead of dynamic. What Can I Use For Unboxing ?. So that it can unbox any primitive datatype. And I should not Use Equals Keyword anywhere in my code. I can use the comparer technique , But It is not working

Equality for primitive types (native to the CLR, like int) is implemented with CIL instructions. The default equality for value types is done by reflection (which is why struct types should provide their own equality).

System.ValueType is a reference type, in order for it to work as a base type for other types. Thus, any struct you pass to a ValueType parameter is boxed, and calling the == operator on them does a reference comparison, as you've noticed.

If you want to pass in structs without boxing, you can use generics and the where T : struct constraint.

Building on @jan.h's answer, I would suggest using:

public static bool EqualsMethod<T>(T value1, T value2) where T: struct

 return value1.Equals(value2);

as a starting point. By constraining to value types (T: struct) then this should meet your requirements.

You can directly use ToString() method from object class, rather than unboxing and storing it in another variable.
eg: value1.ToString() && value2.ToString()

EqualityComparer<T> already has you covered:

public static bool EqualsMethod<T>(T value1, T value2)
 => EqualityComparer<T>.Default.Equals(value1, value2);

By using generics, this works for any T - and in the case of value-type T, it will work without boxing or unboxing. The implementation of .Default here is clever, and has separate implementations for:

• reference types


• naked value types


• 
  Nullable<T> value types

with each implementation doing "the right thing". It also makes use of the IEquatable<T> interface where supported, dropping to .Equals(object) as a fallback.

So: it should do the right thing in all relevant cases. For your own value-types: be sure to implement IEquatable<T>.

If you want to restrict it to just value-types, add a where T : struct clause, but ... that doesn't seem necessary or useful here.