/// <summary>
/// Determines whether the specified <see cref="System.Object"/> is equal to this instance.
/// </summary>
/// <param name="obj">The <see cref="System.Object"/> to compare with this instance.</param>
/// <returns>
/// <c>true</c> if the specified <see cref="System.Object"/> is equal to this instance; otherwise, <c>false</c>.
/// </returns>
public override bool Equals(object obj)
{
// Ez a kódrészlet a Java Method implementációjából való.
// Fontos különbség, hogy itt nem vizsgálom a DeclaringClass-t, azaz nem számít melyik interface-ből való.
// Nem vizsgálom a visszatérési típust sem, mert irreveláns azokban az esetekben, ahol ezt az osztályt használom.
// Ami számít, hogy a neve és a paraméterlistája pontosan megegyezzen.
if (obj != null && obj is MethodComparator)
{
MethodComparator other = (MethodComparator)obj;
if (Method.Name.Equals(other.Method.Name))
{
/* Avoid unnecessary cloning */
ParameterInfo[] params1 = mMethod.GetParameters();
ParameterInfo[] params2 = other.Method.GetParameters();
if (params1.Length == params2.Length)
{
for (int i = 0; i < params1.Length; i++)
{
if (params1[i].ParameterType != params2[i].ParameterType)
{
return(false);
}
}
return(true);
}
}
}
return(false);
}
/// <summary>
/// Initializes a new instance of the <see cref="PropertyComparator"/> class.
/// </summary>
/// <param name="pi">The pi.</param>
public PropertyComparator(PropertyInfo pi)
{
if (pi == null)
{
ThrowHelper.ThrowArgumentNullException("pi");
}
this.mPropertyInfo = pi;
if (pi.GetGetMethod() != null)
{
this.mGetMethod = new MethodComparator(pi.GetGetMethod());
}
if (pi.GetSetMethod() != null)
{
this.mSetMethod = new MethodComparator(pi.GetSetMethod());
}
}
private static void CheckInvalidMethodDeclaration(Type contractInterface, List <MethodComparator> methods)
{
foreach (MethodInfo m in contractInterface.GetMethods())
{
{
OperationContractAttribute ocAnnotation = TypeHelper.GetAttribute <OperationContractAttribute>(m);
if (ocAnnotation != null)
{
// 4. szabály ellenőrzése
if (!m.ReturnType.Equals(typeof(Stream)) && typeof(Stream).IsAssignableFrom(m.ReturnType))
{
throw new InvalidContractDefinitionException(String.Format("Return type '{0}' of the method '{1}' of contract '{2}' is not allowed. Use the base class instead.", m.ReturnType.FullName, m.Name, contractInterface.Name));
}
if (m.GetParameters().Length > 0)
{
foreach (ParameterInfo pt in m.GetParameters())
{
if (!pt.ParameterType.Equals(typeof(Stream)) && typeof(Stream).IsAssignableFrom(pt.ParameterType))
{
throw new InvalidContractDefinitionException(String.Format("Parameter type '{0}' of the method '{1}' of contract '{2}' is not allowed. Use the base class instead.", pt.ParameterType.FullName, m.Name, contractInterface.Name));
}
}
}
// 5. szabály ellenőrzése
if (ocAnnotation.IsOneWay && !m.ReturnType.Equals(typeof(void)))
{
throw new InvalidContractDefinitionException(String.Format("Return type '{0}' of the method '{1}' of contract '{2}' is not allowed for OneWay mode.", m.ReturnType.FullName, m.Name, contractInterface.Name));
}
// 6. szabály ellenőrzése
if (!ocAnnotation.IsOneWay && !ocAnnotation.IsReliable)
{
throw new InvalidContractDefinitionException(String.Format("Invalid reliable mode setting for method '{0}' of the contract type '{1}'. Non reliable communication allowed only for OneWay mode.", m.Name, contractInterface.Name));
}
}
// 7. szabály ellenőrzése
MethodComparator cmp = new MethodComparator(m);
if (methods.Contains(cmp))
{
MethodComparator otherCmp = null;
foreach (MethodComparator mc in methods)
{
if (mc.Equals(cmp))
{
otherCmp = mc;
break;
}
}
OperationContractAttribute otherOcAnnotation = TypeHelper.GetAttribute <OperationContractAttribute>(otherCmp.Method);
if (ocAnnotation == null && otherOcAnnotation == null)
{
// do nothing
}
else if (ocAnnotation != null && otherOcAnnotation != null)
{
if (ocAnnotation.Direction != otherOcAnnotation.Direction)
{
throw new InvalidContractDefinitionException(String.Format("Different {0} definition found on method {1}. Contract interfaces are '{2}' and '{3}'. Setting 'direction' is different.", typeof(OperationContractAttribute).Name, m.Name, contractInterface.Name, otherCmp.Method.DeclaringType.FullName));
}
if (ocAnnotation.IsOneWay != otherOcAnnotation.IsOneWay)
{
throw new InvalidContractDefinitionException(String.Format("Different {0} definition found on method {1}. Contract interfaces are '{2}' and '{3}'. Setting 'isOneWay' is different.", typeof(OperationContractAttribute).Name, m.Name, contractInterface.Name, otherCmp.Method.DeclaringType.FullName));
}
if (ocAnnotation.IsReliable != otherOcAnnotation.IsReliable)
{
throw new InvalidContractDefinitionException(String.Format("Different {0} definition found on method {1}. Contract interfaces are '{2}' and '{3}'. Setting 'isReliable' is different.", typeof(OperationContractAttribute).Name, m.Name, contractInterface.Name, otherCmp.Method.DeclaringType.FullName));
}
if (ocAnnotation.CallTimeout != otherOcAnnotation.CallTimeout)
{
throw new InvalidContractDefinitionException(String.Format("Different {0} definition found on method {1}. Contract interfaces are '{2}' and '{3}'. Setting 'timeout' is different.", typeof(OperationContractAttribute).Name, m.Name, contractInterface.Name, otherCmp.Method.DeclaringType.FullName));
}
}
else
{
// az egyiken van annotáció, a másikon meg nincs
throw new InvalidContractDefinitionException(String.Format("Different {0} definition found on method {1}. Contract interfaces are '{2}' and '{3}'. Same {4} must be exist on methods.", typeof(OperationContractAttribute).Name, m.Name, contractInterface.Name, otherCmp.Method.DeclaringType.FullName, typeof(OperationContractAttribute).Name));
}
}
else
{
methods.Add(cmp);
}
}
}
}
